package com.wicket.okrapp.biz.service.impl;

import cn.hutool.core.bean.BeanUtil;
import com.wicket.okrapp.biz.service.*;
import com.wicket.okrapp.biz.service.dto.req.*;
import com.wicket.okrapp.biz.service.dto.req.ImplementFinanceReceiptsAccountComReqDto;
import com.wicket.okrapp.biz.service.dto.res.*;
import com.wicket.okrapp.biz.service.dto.res.ImplementFinanceReceiptsAccountComRespDto;
import com.wicket.okrapp.common.exception.BizException;
import com.wicket.okrapp.common.util.CommonFunctionHelper;
import com.wicket.okrapp.common.util.RedisUtil;
import java.util.List;
import java.util.stream.Collectors;
import javax.annotation.Resource;

import com.wicket.okrcomponent.integration.*;
import com.wicket.okrcomponent.integration.dto.*;
import com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrfinance.integration.dto.*;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import com.wicket.okrapp.common.exception.Assert;
import com.wicket.okrapp.biz.service.nb.NbFinance;
import com.wicket.okrapp.base.service.MOmsTargetService;
import com.wicket.okrapp.dal.po.mbg.OmsTarget;
import com.wicket.okrapp.base.service.dto.req.QueryTargetDetailReq;
import com.wicket.okrapp.base.service.MOmsEvaluationTemplateService;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationTemplate;
import com.wicket.okrapp.base.service.dto.req.QueryEvaTempDetailReq;
import com.wicket.okrapp.base.service.MOmsEvaluationObjectTargetCycleService;
import com.wicket.okrapp.base.service.MOmsTargetCategoryService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategory;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCatDetailReq;
import com.wicket.okrapp.base.service.MOmsTargetObjectiveService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjective;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjDetailReq;
import com.wicket.okrapp.dal.po.mbg.OmsEvaluationObjectTargetCycle;
import com.wicket.okrapp.base.service.dto.req.BatchQueryEvaObjTargetCycleListByCodesReq;
import com.wicket.okrapp.biz.service.dto.common.FinanceAccountDto;
import com.wicket.okrframework.integration.dto.QueryDeptByCodeListComRespDto;
import com.wicket.okrframework.integration.dto.QueryDeptByCodeListComReqDto;
import java.util.ArrayList;
import cn.hutool.core.collection.CollectionUtil;
import com.wicket.okrframework.integration.FwBaseOrgClient;

import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleDetailReq;
import com.wicket.okrframework.integration.dto.QueryDeptDetailComBorderRespDto;
import com.wicket.okrframework.integration.dto.QueryDeptDetailComBorderReqDto;
import com.wicket.okrfinance.integration.FwFinanceFinanceClient;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComRespDto;
import com.wicket.okrcalc.integration.dto.QueryStandardDataDetailComReqDto;
import com.wicket.okrcalc.integration.FwCalcStandardDataClient;
import com.wicket.okrfinance.integration.FwFinanceTargetContentClient;
import com.wicket.okrapp.base.service.MOmsTaskService;
import com.wicket.okrapp.biz.service.dto.common.AccountSubjectDto;
import com.wicket.okrapp.biz.service.dto.common.TargetBudgetSetDto;
import com.wicket.okrframework.integration.dto.QuerySpaceInfoDetailComRespDto;
import com.wicket.okrframework.integration.dto.QuerySpaceInfoDetailComReqDto;
import com.wicket.okrframework.integration.FwBaseBaseClient;
import com.wicket.okrapp.base.service.dto.req.QueryEvaObjTargetCycleListReq;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.biz.service.dto.common.EvaObjTargetCycleDto;
import com.wicket.okrframework.integration.dto.QuerySpaceDetailComRespDto;
import com.wicket.okrframework.integration.dto.QuerySpaceDetailComReqDto;
import com.wicket.okrapp.biz.service.dto.common.SuperiorEvaObjTargetCycleDto;
import com.wicket.okrapp.biz.service.dto.common.SubCycleDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrapp.base.service.MOmsTargetObjectivePlanExtendService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetObjectivePlanExtend;
import com.wicket.okrapp.base.service.dto.req.QueryTargetObjPlanExDetailReq;
import com.wicket.okrapp.base.service.MOmsTargetCategoryExtendService;
import com.wicket.okrapp.dal.po.mbg.OmsTargetCategoryExtend;
import com.wicket.okrapp.base.service.dto.req.QueryTargetCatExSetDetailReq;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
//import com.wicket.okrapp.integration.dto.QueryConfItemMatchAnswerDetailComReqDto;
import com.wicket.okrfinance.integration.FwFinanceStandardDataClient;
import com.wicket.okrapp.base.service.MOmsTargetAttributionCycleService;
import com.wicket.okrcalc.integration.FwCalcTargetCalcClient;
import com.wicket.okrapp.base.service.MOmsExecuteCycleStageService;

/**
 * @author ：
 * @date ：
 *
 *
 * @version 1.0
 */
@Service
public class FinanceServiceImpl
  implements com.wicket.okrapp.biz.service.FinanceService {

  @Resource
  private RedisUtil redisUtil;
//@Resource
 //private MMmmShellService mMmmShellService;
@Resource
  private VirtualOrgService virtualOrgService;
@Resource
  private NbFinance nbFinance;
@Resource
  private MOmsTargetService mOmsTargetService;
@Resource
  private MOmsEvaluationTemplateService mOmsEvaluationTemplateService;
@Resource
  private MOmsEvaluationObjectTargetCycleService mOmsEvaluationObjectTargetCycleService;
@Resource
  private MOmsTargetCategoryService mOmsTargetCategoryService;
@Resource
  private MOmsTargetObjectiveService mOmsTargetObjectiveService;
@Resource
  private FwCompConfSchemeClient fwCompConfSchemeClient;
@Resource
  private FwBaseOrgClient fwBaseOrgClient;
//@Resource
 //private MOmsAccountService mOmsAccountService;
//@Resource
 //private undefinedService undefinedService;
@Resource
  private InterfaceModeService interfaceModeService;
@Resource
  private FwCompTemplateEngineClient fwCompTemplateEngineClient;
@Resource
  private FwFinanceFinanceClient fwFinanceFinanceClient;
@Resource
  private FwCompInterfaceModeClient fwCompInterfaceModeClient;
@Resource
  private FwCalcStandardDataClient fwCalcStandardDataClient;
@Resource
  private StandardDataService standardDataService;
@Resource
  private FwFinanceTargetContentClient fwFinanceTargetContentClient;
@Resource
  private MOmsTaskService mOmsTaskService;
@Resource
  private TargetContentService targetContentService;
@Resource
  private FwBaseBaseClient fwBaseBaseClient;
@Resource
  private FwCompMessageClient fwCompMessageClient;
@Resource
  private IndexSystemService indexSystemService;
@Resource
  private MOmsTargetObjectivePlanExtendService mOmsTargetObjectivePlanExtendService;
@Resource
  private MOmsTargetCategoryExtendService mOmsTargetCategoryExtendService;
@Resource
  private ExecuteCycleService executeCycleService;
@Resource
  private FwFinanceStandardDataClient fwFinanceStandardDataClient;
@Resource
  private CycleTypeService cycleTypeService;
@Resource
  private FwCompStandardDataClient fwCompStandardDataClient;
@Resource
  private MOmsTargetAttributionCycleService mOmsTargetAttributionCycleService;
@Resource
  private TargetCalcService targetCalcService;
@Resource
  private FwCalcTargetCalcClient fwCalcTargetCalcClient;
@Resource
  private BusinessAtomService businessAtomService;
@Resource
  private MOmsExecuteCycleStageService mOmsExecuteCycleStageService;
@Resource
  private EvaCalcService evaCalcService;
//@Resource
 //private MCustomFields3Service mCustomFields3Service;
//@Resource
//  private FwFinanceTargetContentClient fwFinanceTargetContentClient;
/**
   * D3-执行账单内容对方LOGO和名称处理(公共)[7730]
   * gen by moon at 11/26/2023, 6:21:23 PM
   */
  @Trace(operationName = "D3-执行账单内容对方LOGO和名称处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementLogoAndNameOfBillContentComRespDto implementLogoAndNameOfBillContentCom(ImplementLogoAndNameOfBillContentComReqDto reqDto){
    
      
      ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getAccountOptType() !=null && reqDto.getAccountOptType().equals("ADD_BUDGET")||reqDto!= null&&  reqDto.getAccountOptType() !=null && reqDto.getAccountOptType().equals("DEC_BUDGET"))&&(reqDto!= null&& reqDto.getOppositeLogo() != null &&reqDto!= null&& reqDto.getOppositeName() != null )) {
        //if((D3-执行账单内容对方LOGO和名称处理(公共).账户操作类型 等于 增预算 or D3-执行账单内容对方LOGO和名称处理(公共).账户操作类型 等于 减预算) and (D3-执行账单内容对方LOGO和名称处理(公共).对方logo 值不等于空  and D3-执行账单内容对方LOGO和名称处理(公共).对方名称 值不等于空 ))  52084

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  if(reqDto!=null){
      receptionServiceReq.setOppositeLogo(reqDto.getOppositeLogo());//SimpleFieldAssign//sourceId:1247494_1_52085
receptionServiceReq.setOppositeName(reqDto.getOppositeName());//SimpleFieldAssign//sourceId:1247495_1_52085
    }

    /*约定出参：对方LOGO&对方姓名[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getOppositeLogo(),"D3-执行账单内容对方LOGO和名称处理(公共)-约定出参：对方LOGO&对方姓名-对方logo不能为空",false);
Assert.isNull(receptionServiceReq.getOppositeName(),"D3-执行账单内容对方LOGO和名称处理(公共)-约定出参：对方LOGO&对方姓名-对方名称不能为空",false);
      receptionServiceRes = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
      }
else if((reqDto!= null&&  reqDto.getAccountOptType() !=null && reqDto.getAccountOptType().equals("USE_BUDGET"))){
       //elseif(D3-执行账单内容对方LOGO和名称处理(公共).账户操作类型 等于 使用预算)  52086

QueryVirtualOrgChargeInfoDetailComRespDto queryVirtualOrgChargeInfoDetailComRespDto = null;
    QueryVirtualOrgChargeInfoDetailComReqDto queryVirtualOrgChargeInfoDetailComReqDto=new QueryVirtualOrgChargeInfoDetailComReqDto();
  if(reqDto!=null){
      queryVirtualOrgChargeInfoDetailComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1247506_1_52087
    }

    /*D3-查询虚拟组织角色信息(公共)[7728]   */
    Assert.isNull(queryVirtualOrgChargeInfoDetailComReqDto.getEntityId(),"D3-执行账单内容对方LOGO和名称处理(公共)-D3-查询虚拟组织角色信息(公共)-冗余内容表主键ID不能为空",false);
      queryVirtualOrgChargeInfoDetailComRespDto = virtualOrgService.queryVirtualOrgChargeInfoDetailCom(queryVirtualOrgChargeInfoDetailComReqDto)/*vcase invoke isSameApp*/;



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_2 = null;
    if(queryVirtualOrgChargeInfoDetailComRespDto !=null){
          ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_1=new ImplementAcceptFieldByStandardDataReqDto();
  if(queryVirtualOrgChargeInfoDetailComRespDto!=null){
      receptionServiceReq_1.setOppositeLogo(queryVirtualOrgChargeInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1247494_1_52088
receptionServiceReq_1.setOppositeName(queryVirtualOrgChargeInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1247495_1_52088
    }

    /*约定出参：对方LOGO&对方姓名[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getOppositeLogo(),"D3-执行账单内容对方LOGO和名称处理(公共)-约定出参：对方LOGO&对方姓名-对方logo不能为空",false);
Assert.isNull(receptionServiceReq_1.getOppositeName(),"D3-执行账单内容对方LOGO和名称处理(公共)-约定出参：对方LOGO&对方姓名-对方名称不能为空",false);
      receptionServiceRes_2 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
ImplementLogoAndNameOfBillContentComRespDto retData = new ImplementLogoAndNameOfBillContentComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setOppositeLogo(receptionServiceRes_1.getOppositeLogo());//SimpleFieldAssign//sourceId:1247511_1
retData.setOppositeName(receptionServiceRes_1.getOppositeName());//SimpleFieldAssign//sourceId:1247512_1
    }




return retData;
  }
/**
   * D3-查询资金到账账户标识(公共)[7686]
   * gen by moon at 2/2/2024, 11:17:00 PM
   */
  @Trace(operationName = "D3-查询资金到账账户标识(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryFinanceReceiptsAccountDetailComRespDto queryFinanceReceiptsAccountDetailCom(QueryFinanceReceiptsAccountDetailComReqDto reqDto){


      OmsTarget omsTarget_1 =null;
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 =null;
ImplementAcceptFieldRespDto receptionServiceRes_3 =null;
//virtualUsage 3-3-01查目标详情  51835
      OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  queryTargetDetailReq.setIsArchive("FALSE");//sourceId:1239618_1_51835
if(reqDto!=null){
      queryTargetDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1239616_1_51835
queryTargetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1239617_1_51835
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3-查询资金到账账户标识(公共)-3-3-01查目标详情-目标ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-01查目标详情-归属评价模板ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-01查目标详情-是否存档不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;


      omsTarget_1 = omsTarget;
//virtualUsage D2-3查空间是否开启资金到账  51677
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1237209_1_51677
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_FINANCE");//CUSTOM_CONVENTION//sourceId:1237211_1_51677
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1237212_1_51677

    /*D2-3查空间是否开启资金到账[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-查询资金到账账户标识(公共)-D2-3查空间是否开启资金到账-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-查询资金到账账户标识(公共)-D2-3查空间是否开启资金到账-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-查询资金到账账户标识(公共)-D2-3查空间是否开启资金到账-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("OPEN_CHARGE")||queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("OPEN_FINANCE"))) {
        //if((D2-3查空间是否开启财务.答案值 等于 开启记账 or D2-3查空间是否开启财务.答案值 等于 开启财务))  51678

OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1237686_1_51682
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1237680_1_51682
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    if(omsEvaluationTemplate !=null){
          com.wicket.okrcomponent.integration.dto.QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("IS_OPEN_FUNDS_ARRIVAL");//CUSTOM_CONVENTION//sourceId:1237678_1_51683
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1237679_1_51683
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1237677_1_51683
    }

    /*D2-3查评价主题是否开启资金到账[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3-查询资金到账账户标识(公共)-D2-3查评价主题是否开启资金到账-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-查询资金到账账户标识(公共)-D2-3查评价主题是否开启资金到账-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-查询资金到账账户标识(公共)-D2-3查评价主题是否开启资金到账-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
           }
if((queryConfItemMatchAnswerDetailComRespDto_2!= null&& queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() != null )) {
        //if(D2-3查评价主题是否开启资金到账.答案值 值不等于空 )  51684

//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("TARGET");//CUSTOM_CONVENTION//sourceId:1513169_1_60390
receptionServiceReq.setCustomField2("TARGET_CATEGORY");//CUSTOM_CONVENTION//sourceId:1513170_1_60390
receptionServiceReq.setCustomField3("OBJECTIVE");//CUSTOM_CONVENTION//sourceId:1513171_1_60390

    /*约定：关联归属主体类型编码（目标/目标分类/指标）[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3-查询资金到账账户标识(公共)-约定：关联归属主体类型编码（目标/目标分类/指标）-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3-查询资金到账账户标识(公共)-约定：关联归属主体类型编码（目标/目标分类/指标）-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField3(),"D3-查询资金到账账户标识(公共)-约定：关联归属主体类型编码（目标/目标分类/指标）-自定义字段3不能为空",false);
      receptionServiceRes = nbFinance.implementFourthReceivingField(receptionServiceReq);



QueryClassMatchResultToAnswerDetailComRespDto queryClassMatchResultToAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
    QueryClassMatchResultToAnswerDetailComReqDto queryClassMatchResultToAnswerDetailComReqDto=new QueryClassMatchResultToAnswerDetailComReqDto();
  queryClassMatchResultToAnswerDetailComReqDto.setConfItemClassCode("FINANCE_GROUP");//CUSTOM_CONVENTION//sourceId:1237728_1_51687
queryClassMatchResultToAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1237807_1_51687
if(omsEvaluationTemplate!=null){
      queryClassMatchResultToAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1237761_1_51687
    }

    /*D2-3查预算相关设置[3088]   */
    Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getResultAspObjId(),"D3-查询资金到账账户标识(公共)-D2-3查预算相关设置-开通对象ID不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getConfItemClassCode(),"D3-查询资金到账账户标识(公共)-D2-3查预算相关设置-分组标识不能为空",false);
Assert.isNull(queryClassMatchResultToAnswerDetailComReqDto.getIsPlatData(),"D3-查询资金到账账户标识(公共)-D2-3查预算相关设置-是否标准答案不能为空",false);
      queryClassMatchResultToAnswerDetailComRespDto = fwCompConfSchemeClient.queryClassMatchResultToAnswerDetailCom(queryClassMatchResultToAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryClassMatchResultToAnswerDetailComRespDto!= null&&  queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy() !=null && queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy().equals("PLAN_BUDGET"))) {
        //if(D2-3查预算相关设置.预算层级 等于 预算在规划)  51688

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    if(omsTarget !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setAccountObjectTypeCode(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1512964_1_51689
    }
  if(omsTarget!=null){
      receptionServiceReq_1.setAccountObjectId(omsTarget.getTargetId());//SimpleFieldAssign//sourceId:1240745_1_51689
receptionServiceReq_1.setComCode(omsTarget.getTargetCode());//SimpleFieldAssign//sourceId:1237661_1_51689
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_1.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_1.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_2 = nbFinance.implementAcceptField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
           }
      }
else if((queryClassMatchResultToAnswerDetailComRespDto!= null&&  queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy() !=null && queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy().equals("PRIMARY_CON_TASK_BUDGET"))){
       //elseif(D2-3查预算相关设置.预算层级 等于 一级建设任务)  51691

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
        //if(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 目标分类)  51696

OmsTargetCategory omsTargetCategory = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq.setIsArchive("FALSE");//sourceId:1238065_1_51697
if(reqDto!=null){
      queryTargetCatDetailReq.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238063_1_51697
queryTargetCatDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238064_1_51697
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategory!= null&& omsTargetCategory.getLevelNumber() == 1L)) {
        //if(3-3-02查目标分类详情.层级 等于 1)  51836

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    if(omsTargetCategory !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setAccountObjectTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1512964_1_51837
    }
  if(omsTargetCategory!=null){
      receptionServiceReq_2.setAccountObjectId(omsTargetCategory.getTargetCategoryId());//SimpleFieldAssign//sourceId:1240745_1_51837
receptionServiceReq_2.setComCode(omsTargetCategory.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1237661_1_51837
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_2.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_2.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_4 = nbFinance.implementAcceptField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
           }
      }
else if((omsTargetCategory!= null&& omsTargetCategory.getLevelNumber() > 1L)){
       //elseif(3-3-02查目标分类详情.层级 大于 1)  51838

OmsTargetCategory omsTargetCategory_2 = null;
    if(omsTargetCategory !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_1=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_1.setIsArchive("FALSE");//sourceId:1238065_1_51839
if(omsTargetCategory!=null){
      queryTargetCatDetailReq_1.setTargetCategoryId(omsTargetCategory.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1238063_1_51839
    }
if(reqDto!=null){
      queryTargetCatDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238064_1_51839
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_1.getTargetCategoryId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_1.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_1.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_2 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_5 = null;
    if(omsTargetCategory_2 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_3=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setAccountObjectTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1512964_1_51840
    }
  if(omsTargetCategory_2!=null){
      receptionServiceReq_3.setAccountObjectId(omsTargetCategory_2.getTargetCategoryId());//SimpleFieldAssign//sourceId:1240745_1_51840
receptionServiceReq_3.setComCode(omsTargetCategory_2.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1237661_1_51840
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_3.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_3.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_5 = nbFinance.implementAcceptField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
           }
    }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 指标)  51841

OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:1238070_1_51842
if(reqDto!=null){
      queryTargetObjDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238068_1_51842
queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238069_1_51842
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCategory omsTargetCategory_3 = null;
    if(omsTargetObjective !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_2=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_2.setIsArchive("FALSE");//sourceId:1238065_1_51843
if(omsTargetObjective!=null){
      queryTargetCatDetailReq_2.setTargetCategoryId(omsTargetObjective.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1238063_1_51843
    }
if(reqDto!=null){
      queryTargetCatDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238064_1_51843
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_2.getTargetCategoryId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_2.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_2.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_3 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_6 = null;
    if(omsTargetCategory_3 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_4=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setAccountObjectTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1512964_1_51844
    }
  if(omsTargetCategory_3!=null){
      receptionServiceReq_4.setAccountObjectId(omsTargetCategory_3.getTargetCategoryId());//SimpleFieldAssign//sourceId:1240745_1_51844
receptionServiceReq_4.setComCode(omsTargetCategory_3.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1237661_1_51844
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_4.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_4.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_6 = nbFinance.implementAcceptField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
           }
    }
    }
else if((queryClassMatchResultToAnswerDetailComRespDto!= null&&  queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy() !=null && queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy().equals("LAST_CON_TASK_BUDGET"))){
       //elseif(D2-3查预算相关设置.预算层级 等于 末级建设任务)  51692

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
        //if(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 目标分类)  51699

OmsTargetCategory omsTargetCategory_4 = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq_3=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_3.setIsArchive("FALSE");//sourceId:1238065_1_51701
if(reqDto!=null){
      queryTargetCatDetailReq_3.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238063_1_51701
queryTargetCatDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238064_1_51701
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_3.getTargetCategoryId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_3.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_3.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_4 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategory_4!= null&&  omsTargetCategory_4.getIsLast() !=null && omsTargetCategory_4.getIsLast().equals("TRUE"))) {
        //if(3-3-02查目标分类详情.目标分类是否末级 等于 是)  51831

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_7 = null;
    if(omsTargetCategory_4 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_5=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setAccountObjectTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1512964_1_51832
    }
  if(omsTargetCategory_4!=null){
      receptionServiceReq_5.setAccountObjectId(omsTargetCategory_4.getTargetCategoryId());//SimpleFieldAssign//sourceId:1240745_1_51832
receptionServiceReq_5.setComCode(omsTargetCategory_4.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1237661_1_51832
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_5.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_5.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_7 = nbFinance.implementAcceptField(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_7;
           }
      }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 指标)  51845

OmsTargetObjective omsTargetObjective_2 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_1=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_1.setIsArchive("FALSE");//sourceId:1238070_1_51846
if(reqDto!=null){
      queryTargetObjDetailReq_1.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238068_1_51846
queryTargetObjDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238069_1_51846
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_1.getObjectiveId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_1.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_1.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_2 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCategory omsTargetCategory_5 = null;
    if(omsTargetObjective_2 !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_4=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_4.setIsArchive("FALSE");//sourceId:1238065_1_51847
if(omsTargetObjective_2!=null){
      queryTargetCatDetailReq_4.setTargetCategoryId(omsTargetObjective_2.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:1238063_1_51847
    }
if(reqDto!=null){
      queryTargetCatDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238064_1_51847
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_4.getTargetCategoryId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_4.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_4.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_5 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_8 = null;
    if(omsTargetCategory_5 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_6=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_6.setAccountObjectTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1512964_1_51848
    }
  if(omsTargetCategory_5!=null){
      receptionServiceReq_6.setAccountObjectId(omsTargetCategory_5.getTargetCategoryId());//SimpleFieldAssign//sourceId:1240745_1_51848
receptionServiceReq_6.setComCode(omsTargetCategory_5.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1237661_1_51848
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_6.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_6.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_8 = nbFinance.implementAcceptField(receptionServiceReq_6);


      receptionServiceRes_3 = receptionServiceRes_8;
           }
    }
    }
else if((queryClassMatchResultToAnswerDetailComRespDto!= null&&  queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy() !=null && queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy().equals("ONE_LEVEL_OBSERVATION_POINT_BUDGET"))){
       //elseif(D2-3查预算相关设置.预算层级 等于 一级观测点预算)  51693

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 指标)  51707

OmsTargetObjective omsTargetObjective_3 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_2=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_2.setIsArchive("FALSE");//sourceId:1238070_1_51708
if(reqDto!=null){
      queryTargetObjDetailReq_2.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238068_1_51708
queryTargetObjDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238069_1_51708
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_2.getObjectiveId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_2.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_2.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_3 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjective_3!= null&& omsTargetObjective_3.getLevelNumber() == 1L)) {
        //if(3-3-03查指标详情.层级 等于 1)  51849

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_9 = null;
    if(omsTargetObjective_3 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_7=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_7.setAccountObjectTypeCode(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1512964_1_51850
    }
  if(omsTargetObjective_3!=null){
      receptionServiceReq_7.setAccountObjectId(omsTargetObjective_3.getObjectiveId());//SimpleFieldAssign//sourceId:1240745_1_51850
receptionServiceReq_7.setComCode(omsTargetObjective_3.getObjectiveCode());//SimpleFieldAssign//sourceId:1237661_1_51850
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_7.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_7.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_9 = nbFinance.implementAcceptField(receptionServiceReq_7);


      receptionServiceRes_3 = receptionServiceRes_9;
           }
      }
else if((omsTargetObjective_3!= null&& omsTargetObjective_3.getLevelNumber() > 1L)){
       //elseif(3-3-03查指标详情（入参）.层级 大于 1)  51852

OmsTargetObjective omsTargetObjective_4 = null;
    if(omsTargetObjective_3 !=null){
          QueryTargetObjDetailReq queryTargetObjDetailReq_3=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_3.setIsArchive("FALSE");//sourceId:1238070_1_51853
if(omsTargetObjective_3!=null){
      queryTargetObjDetailReq_3.setObjectiveId(omsTargetObjective_3.getRootObjectiveId());//SimpleFieldAssign//sourceId:1238068_1_51853
    }
if(reqDto!=null){
      queryTargetObjDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238069_1_51853
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_3.getObjectiveId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_3.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_3.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_4 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_10 = null;
    if(omsTargetObjective_4 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_8=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_8.setAccountObjectTypeCode(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1512964_1_51854
    }
  if(omsTargetObjective_4!=null){
      receptionServiceReq_8.setAccountObjectId(omsTargetObjective_4.getObjectiveId());//SimpleFieldAssign//sourceId:1240745_1_51854
receptionServiceReq_8.setComCode(omsTargetObjective_4.getObjectiveCode());//SimpleFieldAssign//sourceId:1237661_1_51854
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
Assert.isNull(receptionServiceReq_8.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_8.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_10 = nbFinance.implementAcceptField(receptionServiceReq_8);


      receptionServiceRes_3 = receptionServiceRes_10;
           }
    }
      }
    }
else if((queryClassMatchResultToAnswerDetailComRespDto!= null&&  queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy() !=null && queryClassMatchResultToAnswerDetailComRespDto.getBudgetHierarchy().equals("LAST_LEVEL_OBSERVATION_POINT_BUDGET"))){
       //elseif(D2-3查预算相关设置.预算层级 等于 末级观测点预算)  51833

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D3-查询资金到账账户标识(公共).关联目标内容类型编码 等于 指标)  51856

OmsTargetObjective omsTargetObjective_5 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_4=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_4.setIsArchive("FALSE");//sourceId:1238070_1_51857
if(reqDto!=null){
      queryTargetObjDetailReq_4.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1238068_1_51857
queryTargetObjDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1238069_1_51857
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_4.getObjectiveId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_4.getEvaluationTemplateId(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_4.getIsArchive(),"D3-查询资金到账账户标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_5 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjective_5!= null&&  omsTargetObjective_5.getIsLastObjective() !=null && omsTargetObjective_5.getIsLastObjective().equals("TRUE"))) {
        //if(3-3-03查指标详情.是否末级指标 等于 是)  51914

//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_11 = null;
    if(omsTargetObjective_5 !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_9=new ImplementAcceptFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_9.setAccountObjectTypeCode(receptionServiceRes.getCustomField3());//SimpleFieldAssign//sourceId:1512964_1_51915
    }
if(omsTargetObjective_5!=null){
      receptionServiceReq_9.setAccountObjectId(omsTargetObjective_5.getObjectiveId());//SimpleFieldAssign//sourceId:1240745_1_51915
receptionServiceReq_9.setComCode(omsTargetObjective_5.getObjectiveCode());//SimpleFieldAssign//sourceId:1237661_1_51915
    }

    /*约定出参：资金到账账户CODE[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_9.getAccountObjectTypeCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体类型编码不能为空",false);
    Assert.isNull(receptionServiceReq_9.getAccountObjectId(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-关联归属主体ID不能为空",false);
Assert.isNull(receptionServiceReq_9.getComCode(),"D3-查询资金到账账户标识(公共)-约定出参：资金到账账户CODE-通用编码标识不能为空",false);
      receptionServiceRes_11 = nbFinance.implementAcceptField(receptionServiceReq_9);


      receptionServiceRes_3 = receptionServiceRes_11;
           }
      }
      }
           }
    }
else{
       //else  51829

//异常结束 51830
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
      }
QueryFinanceReceiptsAccountDetailComRespDto retData = new QueryFinanceReceiptsAccountDetailComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setAccountObjectTypeCode(receptionServiceRes_3.getAccountObjectTypeCode());//SimpleFieldAssign//sourceId:1513206_1
retData.setAccountObjectId(receptionServiceRes_3.getAccountObjectId());//SimpleFieldAssign//sourceId:1240760_1
retData.setFinanceReceiptsAccountCode(receptionServiceRes_3.getComCode());//SimpleFieldAssign//sourceId:1238072_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      retData.setEndValue(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:1241580_1
    }
if(omsTarget_1!=null){
      retData.setTargetCode(omsTarget_1.getTargetCode());//SimpleFieldAssign//sourceId:1512936_1
    }




return retData;
  }
/**
   * D3-查询账户主体列表(公共)[7666]
   * gen by moon at 11/7/2023, 7:13:04 PM
   */
  @Trace(operationName = "D3-查询账户主体列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryFinanceAccountSubjectListComRespDto queryFinanceAccountSubjectListCom(QueryFinanceAccountSubjectListComReqDto reqDto){


      ImplementAcceptFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getLookAncestorNodeList() !=null && reqDto.getLookAncestorNodeList().size()>0&&reqDto!= null&&  reqDto.getAccountObjectClass() !=null && reqDto.getAccountObjectClass().equals("CONTENT_TYPE"))) {
        //if((D3-查询账户主体列表(公共).找祖先列表数据集条数 大于 0 and D3-查询账户主体列表(公共).账户关联主体分类 等于 内容分类))  51627

List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    BatchQueryEvaObjTargetCycleListByCodesReq batchQueryEvaObjTargetCycleListByCodesReq=new BatchQueryEvaObjTargetCycleListByCodesReq();
  batchQueryEvaObjTargetCycleListByCodesReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1234203_1_51629
batchQueryEvaObjTargetCycleListByCodesReq.setTreeTypeCode("PLAN_TREE");//sourceId:1248161_1_51629
batchQueryEvaObjTargetCycleListByCodesReq.setIsParentCycle("TRUE");//sourceId:1231932_1_51629
batchQueryEvaObjTargetCycleListByCodesReq.setIsArchive("FALSE");//sourceId:1231934_1_51629
if(reqDto!=null){
      batchQueryEvaObjTargetCycleListByCodesReq.setEvaObjTargetCycleList(reqDto.getLookAncestorNodeList());//list-field-assign//sourceId:1231925_1_51629
batchQueryEvaObjTargetCycleListByCodesReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1231933_1_51629
    }

    /*3-3-09查询被评对象目标周期列表ByCodes[4774]   */
    Assert.isNull(batchQueryEvaObjTargetCycleListByCodesReq.getEvaObjTypeCode(),"D3-查询账户主体列表(公共)-3-3-09查询被评对象目标周期列表ByCodes-被评对象类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleListByCodesReq.getTreeTypeCode(),"D3-查询账户主体列表(公共)-3-3-09查询被评对象目标周期列表ByCodes-树类型编码不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleListByCodesReq.getIsParentCycle(),"D3-查询账户主体列表(公共)-3-3-09查询被评对象目标周期列表ByCodes-是否父周期不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleListByCodesReq.getEvaluationTemplateId(),"D3-查询账户主体列表(公共)-3-3-09查询被评对象目标周期列表ByCodes-冗余评价模板ID不能为空",false);
Assert.isNull(batchQueryEvaObjTargetCycleListByCodesReq.getIsArchive(),"D3-查询账户主体列表(公共)-3-3-09查询被评对象目标周期列表ByCodes-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.batchQueryEvaObjTargetCycleListByCodes(batchQueryEvaObjTargetCycleListByCodesReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      receptionServiceReq.setFinanceAccountList(//objList-to-objLists
        listOmsEvaluationObjectTargetCycle.stream().map(item -> {
      FinanceAccountDto elm = new FinanceAccountDto();
      elm.setAccountContentCode(item.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:255025_2_51633
elm.setAccountOwnershipType(item.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:255362_2_51633
elm.setAccountObjectId(item.getTargetCycleContentId());//SimpleFieldAssign//sourceId:254645_2_51633
elm.setObjectName(item.getCyclelAlias());//SimpleFieldAssign//sourceId:256523_2_51633
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1233166_1_51633
    }

    /*约定出参数据集：资金账户数据集[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes = nbFinance.implementAcceptField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getLookAncestorNodeList() !=null && reqDto.getLookAncestorNodeList().size()>0&&reqDto!= null&&  reqDto.getAccountObjectClass() !=null && reqDto.getAccountObjectClass().equals("ORGANIZATIONAL_STRUCTURE_TYPE"))){
       //elseif((D3-查询账户主体列表(公共).找祖先列表数据集条数 大于 0 and D3-查询账户主体列表(公共).账户关联主体分类 等于 组织架构分类))  51628

QueryDeptByCodeListComRespDto queryDeptByCodeListComRespDto = null;
    QueryDeptByCodeListComReqDto queryDeptByCodeListComReqDto=new QueryDeptByCodeListComReqDto();
  queryDeptByCodeListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1231473_1_51630
if(reqDto!=null){
      queryDeptByCodeListComReqDto.setDeptList(reqDto.getLookAncestorNodeList());//list-field-assign//sourceId:1231470_1_51630
    }

    /*D1-查询部门列表ByCode(公共)[7668]   */
    Assert.isNull(queryDeptByCodeListComReqDto.getSubjectLifeCycle(),"D3-查询账户主体列表(公共)-D1-查询部门列表ByCode(公共)-主体生命周期不能为空",false);
      queryDeptByCodeListComRespDto = fwBaseOrgClient.queryDeptByCodeListCom(queryDeptByCodeListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldReqDto receptionServiceReq_1=new ImplementAcceptFieldReqDto();
  receptionServiceReq_1.setAccountOwnershipType("DEPT");//sourceId:1235808_1_51676

    /*M3-约定关联主体类型编码：部门[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getAccountOwnershipType(),"D3-查询账户主体列表(公共)-M3-约定关联主体类型编码：部门-账户归属内容类型不能为空",false);
      receptionServiceRes_2 = nbFinance.implementAcceptField(receptionServiceReq_1);



//ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes_4 = null;
    if(queryDeptByCodeListComRespDto !=null){
          ImplementAcceptFieldReqDto receptionServiceReq_2=new ImplementAcceptFieldReqDto();
  if(queryDeptByCodeListComRespDto!= null&&  queryDeptByCodeListComRespDto.getDeptList() !=null&& !CollectionUtil.isEmpty(queryDeptByCodeListComRespDto.getDeptList())){
      ImplementAcceptFieldRespDto finalReceptionServiceRes_ = receptionServiceRes_2;
      receptionServiceReq_2.setFinanceAccountList(//objList-to-objLists
        queryDeptByCodeListComRespDto.getDeptList().stream().map(item -> {
      FinanceAccountDto elm = new FinanceAccountDto();
      if(item!=null){
      elm.setAccountContentCode(item.getDeptCode());//SimpleFieldAssign//sourceId:255025_2_51634
elm.setAccountObjectId(item.getDeptId());//SimpleFieldAssign//sourceId:254645_2_51634
elm.setObjectName(item.getDeptShortName());//SimpleFieldAssign//sourceId:256523_2_51634
    }
if(finalReceptionServiceRes_ !=null){
      elm.setAccountOwnershipType(finalReceptionServiceRes_.getAccountOwnershipType());//两个数组关联数量不一致; 导致逐个赋值; 有概率付错值; //SimpleFieldAssign//sourceId:255362_2_51634
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1233166_1_51634
    }

    /*约定出参数据集：资金账户数据集[6100]  用于特殊方法接收上游入参。 */

      receptionServiceRes_4 = nbFinance.implementAcceptField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_4;
           }
    }
QueryFinanceAccountSubjectListComRespDto retData = new QueryFinanceAccountSubjectListComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setFinanceAccountList(receptionServiceRes_1.getFinanceAccountList().stream().map(item -> BeanUtil.toBean(item, FinanceAccountDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1233286_1
    }




return retData;
  }
/**
   * D3-更新祖先账单账户(公共)[7653]
   * gen by moon at 1/31/2024, 8:41:49 PM
   */
  @Trace(operationName = "D3-更新祖先账单账户(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public RefreshParentBillAndAccountComRespDto refreshParentBillAndAccountCom(RefreshParentBillAndAccountComReqDto reqDto){


      QueryFinanceAccountSubjectListComRespDto queryFinanceAccountSubjectListComRespDto_1 =null;
//virtualUsage D3-查询找祖先列表(公共)  51626
      QueryLookAncestorNodeListComRespDto queryLookAncestorNodeListComRespDto = null;
    QueryLookAncestorNodeListComReqDto queryLookAncestorNodeListComReqDto=new QueryLookAncestorNodeListComReqDto();
  if(reqDto!=null){
      queryLookAncestorNodeListComReqDto.setComCode(reqDto.getComCode());//SimpleFieldAssign//sourceId:1230981_1_51626
    }

    /*D3-查询找祖先列表(公共)[5833]   */
    Assert.isNull(queryLookAncestorNodeListComReqDto.getComCode(),"D3-更新祖先账单账户(公共)-D3-查询找祖先列表(公共)-通用编码标识不能为空",false);
      queryLookAncestorNodeListComRespDto = interfaceModeService.queryLookAncestorNodeListCom(queryLookAncestorNodeListComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3查账户主体列表(公共)  51635
      QueryFinanceAccountSubjectListComRespDto queryFinanceAccountSubjectListComRespDto = null;
    if(queryLookAncestorNodeListComRespDto !=null){
          QueryFinanceAccountSubjectListComReqDto queryFinanceAccountSubjectListComReqDto=new QueryFinanceAccountSubjectListComReqDto();
  if(queryLookAncestorNodeListComRespDto!=null){
      queryFinanceAccountSubjectListComReqDto.setLookAncestorNodeList(queryLookAncestorNodeListComRespDto.getLookAncestorNodeList());//list-field-assign//sourceId:1233277_1_51635
    }
if(reqDto!=null){
      queryFinanceAccountSubjectListComReqDto.setAccountObjectClass(reqDto.getAccountObjectClass());//SimpleFieldAssign//sourceId:1233287_1_51635
queryFinanceAccountSubjectListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1233278_1_51635
    }

    /*D3查账户主体列表(公共)[7666]   */
    Assert.isNull(queryFinanceAccountSubjectListComReqDto.getAccountObjectClass(),"D3-更新祖先账单账户(公共)-D3查账户主体列表(公共)-账户关联主体类型不能为空",false);
Assert.isNull(queryFinanceAccountSubjectListComReqDto.getEvaluationTemplateId(),"D3-更新祖先账单账户(公共)-D3查账户主体列表(公共)-冗余评价模板ID不能为空",false);
      queryFinanceAccountSubjectListComRespDto = queryFinanceAccountSubjectListCom(queryFinanceAccountSubjectListComReqDto)/*vcase invoke 同服务,同domain*/;


      queryFinanceAccountSubjectListComRespDto_1 = queryFinanceAccountSubjectListComRespDto;
           }
if((queryFinanceAccountSubjectListComRespDto!= null&&  queryFinanceAccountSubjectListComRespDto.getFinanceAccountList() !=null && queryFinanceAccountSubjectListComRespDto.getFinanceAccountList().size()>0)) {
        //if(D3查账户主体列表(公共).资金账户列表数据集条数 大于 0)  51641

//ModelCode: circulationCollections
        for (FinanceAccountDto circulationCollectionsRes: queryFinanceAccountSubjectListComRespDto.getFinanceAccountList()){

ImplementLogoAndNameOfBillContentComRespDto implementLogoAndNameOfBillContentComRespDto = null;
    ImplementLogoAndNameOfBillContentComReqDto implementLogoAndNameOfBillContentComReqDto=new ImplementLogoAndNameOfBillContentComReqDto();
  if(reqDto!=null){
      implementLogoAndNameOfBillContentComReqDto.setAccountOptType(reqDto.getAccountOptType());//SimpleFieldAssign//sourceId:1247516_1_52095
implementLogoAndNameOfBillContentComReqDto.setOppositeLogo(reqDto.getOppositeLogo());//SimpleFieldAssign//sourceId:1247513_1_52095
implementLogoAndNameOfBillContentComReqDto.setOppositeName(reqDto.getOppositeName());//SimpleFieldAssign//sourceId:1247514_1_52095
    }
if(circulationCollectionsRes!=null){
      implementLogoAndNameOfBillContentComReqDto.setEntityId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1247515_1_52095
    }

    /*D3-执行账单内容对方LOGO和名称处理(公共)[7730]   */
    Assert.isNull(implementLogoAndNameOfBillContentComReqDto.getAccountOptType(),"D3-更新祖先账单账户(公共)-D3-执行账单内容对方LOGO和名称处理(公共)-账户操作类型不能为空",false);
      implementLogoAndNameOfBillContentComRespDto = implementLogoAndNameOfBillContentCom(implementLogoAndNameOfBillContentComReqDto)/*vcase invoke 同服务,同domain*/;



ImplementFinanceReceiptsAccountComRespDto implementFinanceReceiptsAccountComRespDto = null;
    if(implementLogoAndNameOfBillContentComRespDto !=null){
          ImplementFinanceReceiptsAccountComReqDto implementFinanceReceiptsAccountComReqDto=new ImplementFinanceReceiptsAccountComReqDto();
  implementFinanceReceiptsAccountComReqDto.setAccountOptType("USE_BUDGET");//sourceId:1243578_1_51982
implementFinanceReceiptsAccountComReqDto.setBillTypeCode("INCOME");//sourceId:1243586_1_51982
implementFinanceReceiptsAccountComReqDto.setIsBudgetAccount("FALSE");//sourceId:1243588_1_51982
if(reqDto!=null){
      implementFinanceReceiptsAccountComReqDto.setFinanceReceiptsAccountCode(reqDto.getFinanceReceiptsAccountCode());//SimpleFieldAssign//sourceId:1243580_1_51982
implementFinanceReceiptsAccountComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1243584_1_51982
implementFinanceReceiptsAccountComReqDto.setAccountObjectClass(reqDto.getAccountObjectClass());//SimpleFieldAssign//sourceId:1243585_1_51982
implementFinanceReceiptsAccountComReqDto.setBillAmount(reqDto.getBillAmount());//SimpleFieldAssign//sourceId:1243587_1_51982
implementFinanceReceiptsAccountComReqDto.setIsOrgOfficialAccountNom(reqDto.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1243589_1_51982
implementFinanceReceiptsAccountComReqDto.setCapitalSourceId(reqDto.getCapitalSourceId());//SimpleFieldAssign//sourceId:1243594_1_51982
    }
if(circulationCollectionsRes!=null){
      implementFinanceReceiptsAccountComReqDto.setAccountCode(circulationCollectionsRes.getAccountContentCode());//SimpleFieldAssign//sourceId:1243579_1_51982
implementFinanceReceiptsAccountComReqDto.setAccountObjectTypeCode(circulationCollectionsRes.getAccountOwnershipType());//SimpleFieldAssign//sourceId:1243665_1_51982
implementFinanceReceiptsAccountComReqDto.setAccountObjectId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1243666_1_51982
implementFinanceReceiptsAccountComReqDto.setCurrentContentCode(circulationCollectionsRes.getAccountContentCode());//SimpleFieldAssign//sourceId:1243583_1_51982
implementFinanceReceiptsAccountComReqDto.setTargetContentName(circulationCollectionsRes.getObjectName());//SimpleFieldAssign//sourceId:1243678_1_51982
    }
if(implementLogoAndNameOfBillContentComRespDto!=null){
      implementFinanceReceiptsAccountComReqDto.setOppositeLogo(implementLogoAndNameOfBillContentComRespDto.getOppositeLogo());//SimpleFieldAssign//sourceId:1243591_1_51982
implementFinanceReceiptsAccountComReqDto.setOppositeName(implementLogoAndNameOfBillContentComRespDto.getOppositeName());//SimpleFieldAssign//sourceId:1243592_1_51982
    }

    /*D3-执行资金到账账户处理(公共)[7694]   */
    Assert.isNull(implementFinanceReceiptsAccountComReqDto.getAccountOptType(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-账户操作类型不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getAccountCode(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-当前牌账户标识不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getAccountObjectTypeCode(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-关联归属主体类型编码不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getAccountObjectId(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getCurrentContentCode(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-当前内容标识不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getTargetContentName(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-目标内容名称不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getEvaluationTemplateId(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getAccountObjectClass(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-账户关联主体类型不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getBillTypeCode(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-收支类型不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getBillAmount(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-账单金额不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getIsBudgetAccount(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-是否预算账户不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getIsOrgOfficialAccountNom(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-是否组织正式财务标准不能为空",false);
Assert.isNull(implementFinanceReceiptsAccountComReqDto.getOppositeName(),"D3-更新祖先账单账户(公共)-D3-执行资金到账账户处理(公共)-对方名称不能为空",false);
      implementFinanceReceiptsAccountComRespDto = implementFinanceReceiptsAccountCom(implementFinanceReceiptsAccountComReqDto)/*vcase invoke 同服务,同domain*/;



           }
GenerateBillStreamBizStoryComRespDto generateBillStreamBizStoryComRespDto = null;
    GenerateBillStreamBizStoryComReqDto generateBillStreamBizStoryComReqDto=new GenerateBillStreamBizStoryComReqDto();
  if(reqDto!=null){
      generateBillStreamBizStoryComReqDto.setTemplateSemanticEngineCode(reqDto.getTemplateSemanticEngineCode());//SimpleFieldAssign//sourceId:1243575_1_51981
generateBillStreamBizStoryComReqDto.setIdCardName(reqDto.getIdCardName());//SimpleFieldAssign//sourceId:1243576_1_51981
generateBillStreamBizStoryComReqDto.setAccountSubjectName(reqDto.getAccountSubjectName());//SimpleFieldAssign//sourceId:1246560_1_51981
    }
if(circulationCollectionsRes!=null){
      generateBillStreamBizStoryComReqDto.setTargetContentName(circulationCollectionsRes.getObjectName());//SimpleFieldAssign//sourceId:1243636_1_51981
    }

    /*D2生成账单流水业务故事(公共)[7702]   */
    Assert.isNull(generateBillStreamBizStoryComReqDto.getTemplateSemanticEngineCode(),"D3-更新祖先账单账户(公共)-D2生成账单流水业务故事(公共)-模板引擎标识不能为空",false);
      generateBillStreamBizStoryComRespDto = fwCompTemplateEngineClient.generateBillStreamBizStoryCom(generateBillStreamBizStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementTargetContentAccountAddOrSubComRespDto implementTargetContentAccountAddOrSubComRespDto = null;
    if(generateBillStreamBizStoryComRespDto !=null&&implementLogoAndNameOfBillContentComRespDto !=null){
          ImplementTargetContentAccountAddOrSubComReqDto implementTargetContentAccountAddOrSubComReqDto=new ImplementTargetContentAccountAddOrSubComReqDto();
  if(circulationCollectionsRes!=null){
      implementTargetContentAccountAddOrSubComReqDto.setAccountObjectTypeCode(circulationCollectionsRes.getAccountOwnershipType());//SimpleFieldAssign//sourceId:1243653_1_51980
implementTargetContentAccountAddOrSubComReqDto.setAccountObjectId(circulationCollectionsRes.getAccountObjectId());//SimpleFieldAssign//sourceId:1243651_1_51980
implementTargetContentAccountAddOrSubComReqDto.setCurrentContentCode(circulationCollectionsRes.getAccountContentCode());//SimpleFieldAssign//sourceId:1243564_1_51980
    }
if(reqDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1243562_1_51980
implementTargetContentAccountAddOrSubComReqDto.setBillAmount(reqDto.getBillAmount());//SimpleFieldAssign//sourceId:1243574_1_51980
implementTargetContentAccountAddOrSubComReqDto.setAccountOptType(reqDto.getAccountOptType());//SimpleFieldAssign//sourceId:1243568_1_51980
implementTargetContentAccountAddOrSubComReqDto.setBillTypeCode(reqDto.getBillTypeCode());//SimpleFieldAssign//sourceId:1243563_1_51980
implementTargetContentAccountAddOrSubComReqDto.setAccountObjectClass(reqDto.getAccountObjectClass());//SimpleFieldAssign//sourceId:1243573_1_51980
implementTargetContentAccountAddOrSubComReqDto.setIsBudgetAccount(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1243572_1_51980
implementTargetContentAccountAddOrSubComReqDto.setIsStatisticalAccount(reqDto.getIsStatisticalAccount());//SimpleFieldAssign//sourceId:1511554_1_51980
implementTargetContentAccountAddOrSubComReqDto.setIsOrgOfficialAccountNom(reqDto.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1243571_1_51980
implementTargetContentAccountAddOrSubComReqDto.setContnetAccountSubjectld(reqDto.getContnetAccountSubjectld());//SimpleFieldAssign//sourceId:1243569_1_51980
implementTargetContentAccountAddOrSubComReqDto.setCapitalSourceId(reqDto.getCapitalSourceId());//SimpleFieldAssign//sourceId:1243565_1_51980
    }
if(generateBillStreamBizStoryComRespDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setBillBizStory(generateBillStreamBizStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1243570_1_51980
    }
if(implementLogoAndNameOfBillContentComRespDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setOppositeLogo(implementLogoAndNameOfBillContentComRespDto.getOppositeLogo());//SimpleFieldAssign//sourceId:1243566_1_51980
implementTargetContentAccountAddOrSubComReqDto.setOppositeName(implementLogoAndNameOfBillContentComRespDto.getOppositeName());//SimpleFieldAssign//sourceId:1243567_1_51980
    }

    /*D3执行目标内容账户加减(公共)[7700]   */
    Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectTypeCode(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-关联归属主体类型编码不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectId(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getCurrentContentCode(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-当前内容标识不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getEvaluationTemplateId(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillAmount(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-账单金额不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountOptType(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-账户操作类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillTypeCode(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-收支类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectClass(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-账户关联主体类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getIsBudgetAccount(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-是否预算账户不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getIsStatisticalAccount(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-是否统计账户不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getIsOrgOfficialAccountNom(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-是否组织正式财务标准不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillBizStory(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-流水业务故事信息不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getOppositeName(),"D3-更新祖先账单账户(公共)-D3执行目标内容账户加减(公共)-对方名称不能为空",false);
      implementTargetContentAccountAddOrSubComRespDto = targetContentService.implementTargetContentAccountAddOrSubCom(implementTargetContentAccountAddOrSubComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationEnd
        }

      }
RefreshParentBillAndAccountComRespDto retData = new RefreshParentBillAndAccountComRespDto();
  if(queryFinanceAccountSubjectListComRespDto_1!=null){
      retData.setFinanceAccountList(queryFinanceAccountSubjectListComRespDto_1.getFinanceAccountList().stream().map(item -> BeanUtil.toBean(item, FinanceAccountDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1238150_1
    }




return retData;
  }
/**
   * D3-查询上级账户详情(公共)[7680]
   * gen by moon at 1/30/2024, 2:18:14 AM
   */
  @Trace(operationName = "D3-查询上级账户详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QuerySuperiorsFinanceAccountDetailComRespDto querySuperiorsFinanceAccountDetailCom(QuerySuperiorsFinanceAccountDetailComReqDto reqDto){


      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getAccountObjectClass() !=null && reqDto.getAccountObjectClass().equals("CONTENT_TYPE"))) {
        //if(D3-查询上级账户详情(公共).账户关联主体分类 等于 内容分类)  51659

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1234210_1_51661
queryEvaObjTargetCycleDetailReq.setTreeTypeCode("PLAN_TREE");//sourceId:1234206_1_51661
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1234207_1_51661
queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1234209_1_51661
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getAccountObjectId());//SimpleFieldAssign//sourceId:1247893_1_51661
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1234208_1_51661
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTreeTypeCode(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsEvaluationObjectTargetCycle != null &&omsEvaluationObjectTargetCycle!= null&& omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId() != null )) {
        //if((3-3-09查被评对象目标周期详情.出参 值不等于空  and 3-3-09查被评对象目标周期详情.上级被评对象目标周期标识 值不等于空 ))  51663

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq_1=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq_1.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1234210_1_51664
queryEvaObjTargetCycleDetailReq_1.setTreeTypeCode("PLAN_TREE");//sourceId:1234206_1_51664
queryEvaObjTargetCycleDetailReq_1.setIsParentCycle("TRUE");//sourceId:1234207_1_51664
queryEvaObjTargetCycleDetailReq_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1234209_1_51664
if(omsEvaluationObjectTargetCycle!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247894_1_51664
    }
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1234208_1_51664
    }

    /*3-3-09查被评对象目标周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaObjTypeCode(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getTreeTypeCode(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getIsParentCycle(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getEvaluationTemplateId(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq_1.getSubjectLifeCycle(),"D3-查询上级账户详情(公共)-3-3-09查被评对象目标周期详情-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle_2 = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;


  
           }
QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    if(omsEvaluationObjectTargetCycle_2 !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setIsBudgetAccount(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1234743_1_51670
queryFinanceAccountDetailComReqDto.setIsStatisticalAccount(reqDto.getIsStatisticalAccount());//SimpleFieldAssign//sourceId:1511541_1_51670
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1234884_1_51670
queryFinanceAccountDetailComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1234842_1_51670
    }
if(omsEvaluationObjectTargetCycle_2!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(omsEvaluationObjectTargetCycle_2.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1234745_1_51670
    }

    /*D7-查询资金账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-主体生命周期不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryFinanceAccountDetailComRespDto_1 = queryFinanceAccountDetailComRespDto;
           }
      }
      }
else if((reqDto!= null&&  reqDto.getAccountObjectClass() !=null && reqDto.getAccountObjectClass().equals("ORGANIZATIONAL_STRUCTURE_TYPE"))){
       //elseif(D3-查询上级账户详情(公共).账户关联主体分类 等于 组织架构分类)  51660

QueryDeptDetailComBorderRespDto queryDeptDetailComBorderRespDto = null;
    QueryDeptDetailComBorderReqDto queryDeptDetailComBorderReqDto=new QueryDeptDetailComBorderReqDto();
  if(reqDto!=null){
      queryDeptDetailComBorderReqDto.setDeptId(reqDto.getAccountObjectId());//SimpleFieldAssign//sourceId:1234718_1_51662
    }

    /*D1-3查询部门详情(公共)(边界)[2691]   */
    Assert.isNull(queryDeptDetailComBorderReqDto.getDeptId(),"D3-查询上级账户详情(公共)-D1-3查询部门详情(公共)(边界)-部门ID不能为空",false);
      queryDeptDetailComBorderRespDto = fwBaseOrgClient.queryDeptDetailComBorder(queryDeptDetailComBorderReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryDeptDetailComBorderRespDto!= null&& queryDeptDetailComBorderRespDto.getParentDeptId() != null )) {
        //if(D1-3查询部门详情(公共)(边界).父级部门ID 值不等于空 )  51665

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_2 = null;
    if(queryDeptDetailComBorderRespDto !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_1=new QueryFinanceAccountDetailComReqDto();
  if(reqDto!=null){
      queryFinanceAccountDetailComReqDto_1.setIsBudgetAccount(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1234743_1_51671
queryFinanceAccountDetailComReqDto_1.setIsStatisticalAccount(reqDto.getIsStatisticalAccount());//SimpleFieldAssign//sourceId:1511541_1_51671
queryFinanceAccountDetailComReqDto_1.setSubjectLifeCycle(reqDto.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1234884_1_51671
queryFinanceAccountDetailComReqDto_1.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1234842_1_51671
    }
if(queryDeptDetailComBorderRespDto!=null){
      queryFinanceAccountDetailComReqDto_1.setAccountObjectId(queryDeptDetailComBorderRespDto.getParentDeptId());//SimpleFieldAssign//sourceId:1234745_1_51671
    }

    /*D7-查询资金账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsBudgetAccount(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountObjectId(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getSubjectLifeCycle(),"D3-查询上级账户详情(公共)-D7-查询资金账户详情(公共)-主体生命周期不能为空",false);
      queryFinanceAccountDetailComRespDto_2 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryFinanceAccountDetailComRespDto_1 = queryFinanceAccountDetailComRespDto_2;
           }
      }
    }
QuerySuperiorsFinanceAccountDetailComRespDto retData = new QuerySuperiorsFinanceAccountDetailComRespDto();
  if(queryFinanceAccountDetailComRespDto_1!=null){
      retData.setAccountId(queryFinanceAccountDetailComRespDto_1.getAccountId());//SimpleFieldAssign//sourceId:1234836_1
    }




return retData;
  }
/**
   * D3-执行资金到账账户处理(公共)[7694]
   * gen by moon at 11/24/2023, 11:51:28 AM
   */
  @Trace(operationName = "D3-执行资金到账账户处理(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFinanceReceiptsAccountComRespDto implementFinanceReceiptsAccountCom(ImplementFinanceReceiptsAccountComReqDto reqDto){


      if((reqDto!= null&&  reqDto.getAccountOptType() !=null && reqDto.getAccountOptType().equals("USE_BUDGET"))&&(reqDto!= null&& reqDto.getFinanceReceiptsAccountCode() != null )) {
        //if(D3-执行资金到账账户处理(公共).账户操作类型 等于 使用预算 and D3-执行资金到账账户处理(公共).资金到账账户归属主体标识 值不等于空 )  51752

      ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
    ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto=new ImplementNumericalContrastMagnitudeComReqDto();
  if(reqDto!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara1(reqDto.getAccountCode()!=null?Double.valueOf(reqDto.getAccountCode()):null);//SimpleFieldAssign//sourceId:1239174_1_54566
implementNumericalContrastMagnitudeComReqDto.setCalcPara2(reqDto.getFinanceReceiptsAccountCode()!=null?Double.valueOf(reqDto.getFinanceReceiptsAccountCode()):null);//SimpleFieldAssign//sourceId:1239175_1_54566
    }

    /*D2-比对资金到账账户 CODE 和当前牌账户 CODE[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(),"D3-执行资金到账账户处理(公共)-D2-比对资金到账账户 CODE 和当前牌账户 CODE-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(),"D3-执行资金到账账户处理(公共)-D2-比对资金到账账户 CODE 和当前牌账户 CODE-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto = fwCompInterfaceModeClient.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("BEFORE"))) {
        //if(D2-比对资金到账账户 CODE 和当前牌账户 CODE.数值比较结果 等于 之前（小于）)  54567

QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto = null;
    QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto=new QueryAccountSubjectDetailComReqDto();
  queryAccountSubjectDetailComReqDto.setIncomeExpensesType("INCOME");//sourceId:1243613_1_54568
queryAccountSubjectDetailComReqDto.setAccountSubjectType("CONTNET_STANDARD");//sourceId:1243612_1_54568
queryAccountSubjectDetailComReqDto.setAccountSubjectClassCode("ENTITY_ACCOUNT_CLASS");//sourceId:1243614_1_54568
queryAccountSubjectDetailComReqDto.setBehaviorTypeCode("BUDGET_ARRIVAL");//sourceId:1243619_1_54568
queryAccountSubjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1350202_1_54568

    /*D7查财务科目详情(公共)[7709]   */
    Assert.isNull(queryAccountSubjectDetailComReqDto.getIncomeExpensesType(),"D3-执行资金到账账户处理(公共)-D7查财务科目详情(公共)-收支类型不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getAccountSubjectType(),"D3-执行资金到账账户处理(公共)-D7查财务科目详情(公共)-科目类型不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getAccountSubjectClassCode(),"D3-执行资金到账账户处理(公共)-D7查财务科目详情(公共)-科目类别编码不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getBehaviorTypeCode(),"D3-执行资金到账账户处理(公共)-D7查财务科目详情(公共)-行为类型编码不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getSubjectLifeCycle(),"D3-执行资金到账账户处理(公共)-D7查财务科目详情(公共)-主体生命周期不能为空",false);
      queryAccountSubjectDetailComRespDto = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



GenerateBillStreamBizStoryComRespDto generateBillStreamBizStoryComRespDto = null;
    GenerateBillStreamBizStoryComReqDto generateBillStreamBizStoryComReqDto=new GenerateBillStreamBizStoryComReqDto();
  generateBillStreamBizStoryComReqDto.setTemplateSemanticEngineCode("BUDGET_ARRIVAL_STORY");//CUSTOM_CONVENTION//sourceId:1243620_1_54569
if(reqDto!=null){
      generateBillStreamBizStoryComReqDto.setTargetContentName(reqDto.getTargetContentName());//SimpleFieldAssign//sourceId:1243637_1_54569
    }

    /*D2生成账单流水业务故事(公共)[7702]   */
    Assert.isNull(generateBillStreamBizStoryComReqDto.getTemplateSemanticEngineCode(),"D3-执行资金到账账户处理(公共)-D2生成账单流水业务故事(公共)-模板引擎标识不能为空",false);
Assert.isNull(generateBillStreamBizStoryComReqDto.getTargetContentName(),"D3-执行资金到账账户处理(公共)-D2生成账单流水业务故事(公共)-目标内容名称不能为空",false);
      generateBillStreamBizStoryComRespDto = fwCompTemplateEngineClient.generateBillStreamBizStoryCom(generateBillStreamBizStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



ImplementTargetContentAccountAddOrSubComRespDto implementTargetContentAccountAddOrSubComRespDto = null;
    if(generateBillStreamBizStoryComRespDto !=null&&queryAccountSubjectDetailComRespDto !=null){
          ImplementTargetContentAccountAddOrSubComReqDto implementTargetContentAccountAddOrSubComReqDto=new ImplementTargetContentAccountAddOrSubComReqDto();
  if(reqDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setAccountOptType(reqDto.getAccountOptType());//SimpleFieldAssign//sourceId:1243438_1_54570
implementTargetContentAccountAddOrSubComReqDto.setAccountObjectTypeCode(reqDto.getAccountObjectTypeCode());//SimpleFieldAssign//sourceId:1243646_1_54570
implementTargetContentAccountAddOrSubComReqDto.setAccountObjectId(reqDto.getAccountObjectId());//SimpleFieldAssign//sourceId:1243652_1_54570
implementTargetContentAccountAddOrSubComReqDto.setCurrentContentCode(reqDto.getCurrentContentCode());//SimpleFieldAssign//sourceId:1243434_1_54570
implementTargetContentAccountAddOrSubComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1243431_1_54570
implementTargetContentAccountAddOrSubComReqDto.setAccountObjectClass(reqDto.getAccountObjectClass());//SimpleFieldAssign//sourceId:1243505_1_54570
implementTargetContentAccountAddOrSubComReqDto.setBillTypeCode(reqDto.getBillTypeCode());//SimpleFieldAssign//sourceId:1243433_1_54570
implementTargetContentAccountAddOrSubComReqDto.setBillAmount(reqDto.getBillAmount());//SimpleFieldAssign//sourceId:1243504_1_54570
implementTargetContentAccountAddOrSubComReqDto.setIsBudgetAccount(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1243442_1_54570
implementTargetContentAccountAddOrSubComReqDto.setIsOrgOfficialAccountNom(reqDto.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1243441_1_54570
implementTargetContentAccountAddOrSubComReqDto.setOppositeLogo(reqDto.getOppositeLogo());//SimpleFieldAssign//sourceId:1243436_1_54570
implementTargetContentAccountAddOrSubComReqDto.setOppositeName(reqDto.getOppositeName());//SimpleFieldAssign//sourceId:1243437_1_54570
implementTargetContentAccountAddOrSubComReqDto.setCapitalSourceId(reqDto.getCapitalSourceId());//SimpleFieldAssign//sourceId:1243435_1_54570
    }
if(generateBillStreamBizStoryComRespDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setBillBizStory(generateBillStreamBizStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1243440_1_54570
    }
if(queryAccountSubjectDetailComRespDto!=null){
      implementTargetContentAccountAddOrSubComReqDto.setContnetAccountSubjectld(queryAccountSubjectDetailComRespDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1243439_1_54570
    }

    /*D3-执行实体到账账户资金加处理(公共)[7700]   */
    Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountOptType(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-账户操作类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectTypeCode(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-关联归属主体类型编码不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectId(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getCurrentContentCode(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-当前内容标识不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getEvaluationTemplateId(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getAccountObjectClass(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-账户关联主体类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillTypeCode(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-收支类型不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillAmount(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-账单金额不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getIsBudgetAccount(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-是否预算账户不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getIsOrgOfficialAccountNom(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-是否组织正式财务标准不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getBillBizStory(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-流水业务故事信息不能为空",false);
Assert.isNull(implementTargetContentAccountAddOrSubComReqDto.getOppositeName(),"D3-执行资金到账账户处理(公共)-D3-执行实体到账账户资金加处理(公共)-对方名称不能为空",false);
      implementTargetContentAccountAddOrSubComRespDto = targetContentService.implementTargetContentAccountAddOrSubCom(implementTargetContentAccountAddOrSubComReqDto)/*vcase invoke isSameApp*/;



           }
           }
      }
ImplementFinanceReceiptsAccountComRespDto retData = new ImplementFinanceReceiptsAccountComRespDto();





return retData;
  }
/**
   * D3-执行提交预算条件分析(公共)[7704]
   * gen by moon at 3/5/2024, 1:02:10 AM
   */
  @Trace(operationName = "D3-执行提交预算条件分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementSubmitBudgetAnalyzeComRespDto implementSubmitBudgetAnalyzeCom(ImplementSubmitBudgetAnalyzeComReqDto reqDto){


      //virtualUsage 3-2-02查评价模板详情  61900
      OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562559_1_61900
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1562558_1_61900
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3-执行提交预算条件分析(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getSubjectLifeCycle(),"D3-执行提交预算条件分析(公共)-3-2-02查评价模板详情-主体生命周期不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



      //virtualUsage D2-3查是否开启资金到账  61875
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    if(omsEvaluationTemplate !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_FUNDS_ARRIVAL");//CUSTOM_CONVENTION//sourceId:1562319_1_61875
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1562320_1_61875
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1562318_1_61875
    }

    /*D2-3查是否开启资金到账[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-执行提交预算条件分析(公共)-D2-3查是否开启资金到账-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-执行提交预算条件分析(公共)-D2-3查是否开启资金到账-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-执行提交预算条件分析(公共)-D2-3查是否开启资金到账-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）  61915
      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setAccountStatus("NORMAL");//sourceId:1562655_1_61915
queryFinanceAccountDetailComReqDto.setIsStatisticalAccount("FALSE");//sourceId:1562684_1_61915
queryFinanceAccountDetailComReqDto.setIsBudgetAccount("FALSE");//sourceId:1562659_1_61915
queryFinanceAccountDetailComReqDto.setIsEndStatus("FALSE");//sourceId:1562685_1_61915
queryFinanceAccountDetailComReqDto.setCertificationStatus("AUTHENTICATED");//sourceId:1562686_1_61915
queryFinanceAccountDetailComReqDto.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562660_1_61915
queryFinanceAccountDetailComReqDto.setAccountObjectClass("CONTENT_TYPE");//sourceId:1562661_1_61915
queryFinanceAccountDetailComReqDto.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562687_1_61915
queryFinanceAccountDetailComReqDto.setDistributionSystemTypeCode("CAPITAL_SYSTEM");//sourceId:1562665_1_61915
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562667_1_61915
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1562670_1_61915
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1562662_1_61915
    }

    /*D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountStatus(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsStatisticalAccount(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsEndStatus(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-是否结束状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getCertificationStatus(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-认证状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getEcologicalAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-生态账户类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectClass(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-账户类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getDistributionSystemTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-发行体系类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3-执行提交预算条件分析(公共)-D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryFinanceAccountDetailComRespDto== null||  queryFinanceAccountDetailComRespDto.getSettlableBalance() ==null||queryFinanceAccountDetailComRespDto== null||  queryFinanceAccountDetailComRespDto.getRelSubBudgetAccountCode() ==null,"找不到数据，系统异常",false);


if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("TRUE"))) {
        //if(D2-3查是否开启资金到账.答案值 等于 是)  51935

if((queryFinanceAccountDetailComRespDto!= null&&  queryFinanceAccountDetailComRespDto.getIsIncomingAccount() !=null && queryFinanceAccountDetailComRespDto.getIsIncomingAccount().equals("FALSE"))) {
        //if(D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）.是否到账账户 等于 否)  61916

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_2 = null;
    if(queryFinanceAccountDetailComRespDto !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_1=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto_1.setIsBudgetAccount("TRUE");//sourceId:1562259_1_61920
queryFinanceAccountDetailComReqDto_1.setIsStatisticalAccount("FALSE");//sourceId:1562729_1_61920
queryFinanceAccountDetailComReqDto_1.setIsEndStatus("FALSE");//sourceId:1562726_1_61920
queryFinanceAccountDetailComReqDto_1.setCertificationStatus("AUTHENTICATED");//sourceId:1562727_1_61920
queryFinanceAccountDetailComReqDto_1.setAccountStatus("NORMAL");//sourceId:1562254_1_61920
queryFinanceAccountDetailComReqDto_1.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562728_1_61920
queryFinanceAccountDetailComReqDto_1.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562260_1_61920
queryFinanceAccountDetailComReqDto_1.setAccountObjectClass("CONTENT_TYPE");//sourceId:1562730_1_61920
queryFinanceAccountDetailComReqDto_1.setDistributionSystemTypeCode("CAPITAL_SYSTEM");//sourceId:1562731_1_61920
queryFinanceAccountDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562257_1_61920
queryFinanceAccountDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1562258_1_61920
    if(queryFinanceAccountDetailComRespDto !=null){
      queryFinanceAccountDetailComReqDto_1.setAccountContentCode(queryFinanceAccountDetailComRespDto.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1562256_1_61920
    }

    /*D7-查询预算账户详情（获取预算账户归属内容主体ID）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountContentCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-关联归属主体标识不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsBudgetAccount(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsStatisticalAccount(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getIsEndStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否结束状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getCertificationStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-认证状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getEcologicalAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-生态账户类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getAccountObjectClass(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getDistributionSystemTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-发行体系类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getSubjectLifeCycle(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_1.getSpaceId(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto_2 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryFinanceAccountDetailComRespDto_2== null||  queryFinanceAccountDetailComRespDto_2.getAccountObjectId() ==null||queryFinanceAccountDetailComRespDto_2== null||  queryFinanceAccountDetailComRespDto_2.getSettlableBalance() ==null,"找不到数据，系统异常",false);


           }
QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_4 = null;
    if(queryFinanceAccountDetailComRespDto_2 !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_2=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto_2.setAccountStatus("NORMAL");//sourceId:1562735_1_61923
queryFinanceAccountDetailComReqDto_2.setIsEndStatus("FALSE");//sourceId:1562736_1_61923
queryFinanceAccountDetailComReqDto_2.setCertificationStatus("AUTHENTICATED");//sourceId:1562737_1_61923
queryFinanceAccountDetailComReqDto_2.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562738_1_61923
queryFinanceAccountDetailComReqDto_2.setIsBudgetAccount("FALSE");//sourceId:1562739_1_61923
queryFinanceAccountDetailComReqDto_2.setIsStatisticalAccount("TRUE");//sourceId:1562740_1_61923
queryFinanceAccountDetailComReqDto_2.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562741_1_61923
queryFinanceAccountDetailComReqDto_2.setAccountObjectClass("CONTENT_TYPE");//sourceId:1562742_1_61923
queryFinanceAccountDetailComReqDto_2.setDistributionSystemTypeCode("CAPITAL_SYSTEM");//sourceId:1562743_1_61923
queryFinanceAccountDetailComReqDto_2.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562744_1_61923
queryFinanceAccountDetailComReqDto_2.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1562734_1_61923
if(queryFinanceAccountDetailComRespDto_2!=null){
      queryFinanceAccountDetailComReqDto_2.setAccountObjectId(queryFinanceAccountDetailComRespDto_2.getAccountObjectId());//SimpleFieldAssign//sourceId:1562733_1_61923
    }

    /*D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto_2.getAccountObjectId(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getAccountStatus(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getIsEndStatus(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-是否结束状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getCertificationStatus(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-认证状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-账户类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getIsBudgetAccount(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getIsStatisticalAccount(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getEcologicalAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-生态账户类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getAccountObjectClass(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getDistributionSystemTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-发行体系类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getSubjectLifeCycle(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_2.getSpaceId(),"D3-执行提交预算条件分析(公共)-D7-查预算层级对应的实体到账账户（获取可用金额用于比大小）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto_4 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryFinanceAccountDetailComRespDto_4== null||  queryFinanceAccountDetailComRespDto_4.getSettlableBalance() ==null,"找不到数据，系统异常",false);


           }
ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
    if(queryFinanceAccountDetailComRespDto_4 !=null){
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto=new ImplementNumericalContrastMagnitudeComReqDto();
  if(reqDto!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara1(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1562690_1_61924
    }
if(queryFinanceAccountDetailComRespDto_4!=null){
      implementNumericalContrastMagnitudeComReqDto.setCalcPara2(queryFinanceAccountDetailComRespDto_4.getSettlableBalance());//SimpleFieldAssign//sourceId:1562691_1_61924
    }

    /*D2账户可用余额与账单金额比大小(公共)[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto = fwCompInterfaceModeClient.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementNumericalContrastMagnitudeComRespDto!= null&&  implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("LATER"))) {
        //if(D2账户可用余额与账单金额比大小(公共).数值比较结果 等于 之后（大于）)  61927

//异常结束 61928
      throw new BizException("CC10000265","对不起！余额不足~",false);
      }
      }
else if((queryFinanceAccountDetailComRespDto!= null&&  queryFinanceAccountDetailComRespDto.getIsIncomingAccount() !=null && queryFinanceAccountDetailComRespDto.getIsIncomingAccount().equals("TRUE"))){
       //elseif(D7-查询当前内容实体账户（获取预算扣减账户归属主体标识）.是否到账账户 等于 是)  61917

ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto_2 = null;
    if(queryFinanceAccountDetailComRespDto !=null){
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto_1=new ImplementNumericalContrastMagnitudeComReqDto();
if(reqDto!=null){
      implementNumericalContrastMagnitudeComReqDto_1.setCalcPara1(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1562690_1_61921
    }
if(queryFinanceAccountDetailComRespDto!=null){
      implementNumericalContrastMagnitudeComReqDto_1.setCalcPara2(queryFinanceAccountDetailComRespDto.getSettlableBalance());//SimpleFieldAssign//sourceId:1562691_1_61921
    }

    /*D2账户可用余额与账单金额比大小(公共)[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto_1.getCalcPara1(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto_1.getCalcPara2(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto_2 = fwCompInterfaceModeClient.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementNumericalContrastMagnitudeComRespDto_2!= null&&  implementNumericalContrastMagnitudeComRespDto_2.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto_2.getNumCompareResult().equals("LATER"))) {
        //if(D2账户可用余额与账单金额比大小(公共).数值比较结果 等于 之后（大于）)  61929

//异常结束 61930
      throw new BizException("CC10000265","对不起！余额不足~",false);
      }
    }
else{
       //else  61918

//异常结束 61919
      throw new BizException("C00028","对不起，没有数据！！",false);
           }
      }
else if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("FALSE"))){
       //elseif(D2-3查是否开启资金到账.答案值 等于 否)  61869

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    if(omsEvaluationTemplate !=null){
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("IS_ALLOW_BUDGET_OVERRUNS");//CUSTOM_CONVENTION//sourceId:1562344_1_61876
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1562345_1_61876
if(omsEvaluationTemplate!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(omsEvaluationTemplate.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1562343_1_61876
    }

    /*D2-3查是否允许预算超支[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3-执行提交预算条件分析(公共)-D2-3查是否允许预算超支-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-执行提交预算条件分析(公共)-D2-3查是否允许预算超支-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-执行提交预算条件分析(公共)-D2-3查是否允许预算超支-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("FALSE"))) {
        //if(D2-3查是否允许预算超支.答案值 等于 否)  61877

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto_6 = null;
    if(queryFinanceAccountDetailComRespDto !=null){
          QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto_3=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto_3.setIsBudgetAccount("TRUE");//sourceId:1562259_1_61925
queryFinanceAccountDetailComReqDto_3.setIsStatisticalAccount("FALSE");//sourceId:1562729_1_61925
queryFinanceAccountDetailComReqDto_3.setIsEndStatus("FALSE");//sourceId:1562726_1_61925
queryFinanceAccountDetailComReqDto_3.setCertificationStatus("AUTHENTICATED");//sourceId:1562727_1_61925
queryFinanceAccountDetailComReqDto_3.setAccountStatus("NORMAL");//sourceId:1562254_1_61925
queryFinanceAccountDetailComReqDto_3.setAccountTypeCode("ECOLOGICAL_ACCOUNT");//sourceId:1562728_1_61925
queryFinanceAccountDetailComReqDto_3.setEcologicalAccountTypeCode("TARGET_CONTENT_ACCOUNT");//sourceId:1562260_1_61925
queryFinanceAccountDetailComReqDto_3.setAccountObjectClass("CONTENT_TYPE");//sourceId:1562730_1_61925
queryFinanceAccountDetailComReqDto_3.setDistributionSystemTypeCode("CAPITAL_SYSTEM");//sourceId:1562731_1_61925
queryFinanceAccountDetailComReqDto_3.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562257_1_61925
queryFinanceAccountDetailComReqDto_3.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1562258_1_61925
if(queryFinanceAccountDetailComRespDto!=null){
      queryFinanceAccountDetailComReqDto_3.setAccountContentCode(queryFinanceAccountDetailComRespDto.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1562256_1_61925
    }

    /*D7-查询预算账户详情（获取预算账户归属内容主体ID）[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto_3.getAccountContentCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-关联归属主体标识不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getIsBudgetAccount(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getIsStatisticalAccount(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getIsEndStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-是否结束状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getCertificationStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-认证状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getAccountStatus(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getEcologicalAccountTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-生态账户类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getAccountObjectClass(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getDistributionSystemTypeCode(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-发行体系类型编码不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getSubjectLifeCycle(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto_3.getSpaceId(),"D3-执行提交预算条件分析(公共)-D7-查询预算账户详情（获取预算账户归属内容主体ID）-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto_6 = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryFinanceAccountDetailComRespDto_6== null||  queryFinanceAccountDetailComRespDto_6.getAccountObjectId() ==null||queryFinanceAccountDetailComRespDto_6== null||  queryFinanceAccountDetailComRespDto_6.getSettlableBalance() ==null,"找不到数据，系统异常",false);


           }
ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto_3 = null;
    if(queryFinanceAccountDetailComRespDto_6 !=null){
          ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto_2=new ImplementNumericalContrastMagnitudeComReqDto();
if(reqDto!=null){
      implementNumericalContrastMagnitudeComReqDto_2.setCalcPara1(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1562690_1_61926
    }
if(queryFinanceAccountDetailComRespDto_6!=null){
      implementNumericalContrastMagnitudeComReqDto_2.setCalcPara2(queryFinanceAccountDetailComRespDto_6.getSettlableBalance());//SimpleFieldAssign//sourceId:1562691_1_61926
    }

    /*D2账户可用余额与账单金额比大小(公共)[5551]   */
    Assert.isNull(implementNumericalContrastMagnitudeComReqDto_2.getCalcPara1(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参1不能为空",false);
Assert.isNull(implementNumericalContrastMagnitudeComReqDto_2.getCalcPara2(),"D3-执行提交预算条件分析(公共)-D2账户可用余额与账单金额比大小(公共)-计算入参2不能为空",false);
      implementNumericalContrastMagnitudeComRespDto_3 = fwCompInterfaceModeClient.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }
if((implementNumericalContrastMagnitudeComRespDto_3!= null&&  implementNumericalContrastMagnitudeComRespDto_3.getNumCompareResult() !=null && implementNumericalContrastMagnitudeComRespDto_3.getNumCompareResult().equals("LATER"))) {
        //if(D2账户可用余额与账单金额比大小(公共).数值比较结果 等于 之后（大于）)  61931

//异常结束 61932
      throw new BizException("CC10000265","对不起！余额不足~",false);
           }
           }
      }
ImplementSubmitBudgetAnalyzeComRespDto retData = new ImplementSubmitBudgetAnalyzeComRespDto();





return retData;
  }
/**
   * D3-审核并计算预算标准数据(公共)[7726]
   * gen by moon at 1/31/2024, 8:44:57 PM
   */
  @Trace(operationName = "D3-审核并计算预算标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementExamineCalcBudgetDataComRespDto implementExamineCalcBudgetDataCom(ImplementExamineCalcBudgetDataComReqDto reqDto){


      //步骤0: M3-接收字段用于汇报任务（特殊方法） - implementAcceptFieldByStandardData
     //ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1246474_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1246475_1
receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1246708_1
receptionServiceReq.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1246720_1
receptionServiceReq.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1246709_1
receptionServiceReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1246476_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1246477_1
    }

    /*M3-接收入参字段[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-关联目标内容类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getCycleId(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getTargetId(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-冗余目标ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-审核并计算预算标准数据(公共)-M3-接收入参字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期详情 - queryEvaObjTargetCycleDetail
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1247794_1
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1247792_1
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1247793_1
    }

    /*3-3-09查目标周期详情（获取周期ID和目标内容标识）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTargetCycleId(),"D3-审核并计算预算标准数据(公共)-3-3-09查目标周期详情（获取周期ID和目标内容标识）-被评对象目标周期ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3-审核并计算预算标准数据(公共)-3-3-09查目标周期详情（获取周期ID和目标内容标识）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getSubjectLifeCycle(),"D3-审核并计算预算标准数据(公共)-3-3-09查目标周期详情（获取周期ID和目标内容标识）-主体生命周期不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;




//步骤2: D4-1查标准数据详情(公共) - queryStandardDataDetailCom
     QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1246806_1
queryStandardDataDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1246807_1
queryStandardDataDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1246810_1
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1246805_1
queryStandardDataDetailComReqDto.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1246809_1
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1246808_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      queryStandardDataDetailComReqDto.setPeriodId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1246804_1
    }

    /*D4-1查标准数据详情（获取预算支出金额及科目分类ID）[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getPeriodId(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getUpdateCycleId(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-数据类型编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-数据使用场景编码不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getSubjectLifeCycle(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-主体生命周期不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3-审核并计算预算标准数据(公共)-D4-1查标准数据详情（获取预算支出金额及科目分类ID）-主题内容ID不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤3: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
     QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto = null;
    if(queryStandardDataDetailComRespDto !=null){
    QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto=new QueryAccountSubjectDetailComReqDto();
  queryAccountSubjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1350203_1
if(queryStandardDataDetailComRespDto!=null){
      queryAccountSubjectDetailComReqDto.setAccountSubjectld(queryStandardDataDetailComRespDto.getExtendedField3());//SimpleFieldAssign//sourceId:1246824_1
    }

    /*D7-查财务科目详情（获取科目名称）[7709]   */
    Assert.isNull(queryAccountSubjectDetailComReqDto.getAccountSubjectld(),"D3-审核并计算预算标准数据(公共)-D7-查财务科目详情（获取科目名称）-科目ID不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getSubjectLifeCycle(),"D3-审核并计算预算标准数据(公共)-D7-查财务科目详情（获取科目名称）-主体生命周期不能为空",false);
      queryAccountSubjectDetailComRespDto = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤4: D3-执行填报评价角色转换(公共) - implementEvaluationRoleConvertCom
     ImplementEvaluationRoleConvertComRespDto implementEvaluationRoleConvertComRespDto = null;
    ImplementEvaluationRoleConvertComReqDto implementEvaluationRoleConvertComReqDto=new ImplementEvaluationRoleConvertComReqDto();
  implementEvaluationRoleConvertComReqDto.setRoleCode("PRINCIPAL");//CUSTOM_CONVENTION//sourceId:1354122_1
if(reqDto!=null){
      implementEvaluationRoleConvertComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1354123_1
implementEvaluationRoleConvertComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1354124_1
implementEvaluationRoleConvertComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1354125_1
    }

    /*D3-执行内容负责人角色转换[7617]   */
    Assert.isNull(implementEvaluationRoleConvertComReqDto.getRoleCode(),"D3-审核并计算预算标准数据(公共)-D3-执行内容负责人角色转换-角色标识不能为空",false);
Assert.isNull(implementEvaluationRoleConvertComReqDto.getTargetCycleContentId(),"D3-审核并计算预算标准数据(公共)-D3-执行内容负责人角色转换-关联目标内容ID不能为空",false);
Assert.isNull(implementEvaluationRoleConvertComReqDto.getTargetCycleContentTypeCode(),"D3-审核并计算预算标准数据(公共)-D3-执行内容负责人角色转换-关联目标内容类型编码不能为空",false);
Assert.isNull(implementEvaluationRoleConvertComReqDto.getEvaluationTemplateId(),"D3-审核并计算预算标准数据(公共)-D3-执行内容负责人角色转换-冗余评价模板ID不能为空",false);
      implementEvaluationRoleConvertComRespDto = virtualOrgService.implementEvaluationRoleConvertCom(implementEvaluationRoleConvertComReqDto)/*vcase invoke isSameApp*/;




//步骤5: D3-查询虚拟组织角色信息(公共) - queryVirtualOrgChargeInfoDetailCom
     QueryVirtualOrgChargeInfoDetailComRespDto queryVirtualOrgChargeInfoDetailComRespDto = null;
    if(implementEvaluationRoleConvertComRespDto !=null){
    QueryVirtualOrgChargeInfoDetailComReqDto queryVirtualOrgChargeInfoDetailComReqDto=new QueryVirtualOrgChargeInfoDetailComReqDto();
  if(reqDto!=null){
      queryVirtualOrgChargeInfoDetailComReqDto.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1247086_1
    }
if(implementEvaluationRoleConvertComRespDto!=null){
      queryVirtualOrgChargeInfoDetailComReqDto.setRoleCode(implementEvaluationRoleConvertComRespDto.getRoleCode());//SimpleFieldAssign//sourceId:1353451_1
    }

    /*D3-查当前内容圈子负责人信息（获取头像和名称）[7728]   */
    Assert.isNull(queryVirtualOrgChargeInfoDetailComReqDto.getEntityId(),"D3-审核并计算预算标准数据(公共)-D3-查当前内容圈子负责人信息（获取头像和名称）-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgChargeInfoDetailComReqDto.getRoleCode(),"D3-审核并计算预算标准数据(公共)-D3-查当前内容圈子负责人信息（获取头像和名称）-角色标识不能为空",false);
      queryVirtualOrgChargeInfoDetailComRespDto = virtualOrgService.queryVirtualOrgChargeInfoDetailCom(queryVirtualOrgChargeInfoDetailComReqDto)/*vcase invoke isSameApp*/;



           }

//步骤6: D2生成账单流水业务故事(公共) - generateBillStreamBizStoryCom
     GenerateBillStreamBizStoryComRespDto generateBillStreamBizStoryComRespDto = null;
    if(queryAccountSubjectDetailComRespDto !=null){
          GenerateBillStreamBizStoryComReqDto generateBillStreamBizStoryComReqDto=new GenerateBillStreamBizStoryComReqDto();
  generateBillStreamBizStoryComReqDto.setTemplateSemanticEngineCode("CHARGE_EXPENDITURE_STORY");//CUSTOM_CONVENTION//sourceId:1246694_1
if(queryAccountSubjectDetailComRespDto!=null){
      generateBillStreamBizStoryComReqDto.setAccountSubjectName(queryAccountSubjectDetailComRespDto.getAccountSubjectName());//SimpleFieldAssign//sourceId:1246698_1
    }

    /*D2-生成当前目标内容账单流水业务故事[7702]   */
    Assert.isNull(generateBillStreamBizStoryComReqDto.getTemplateSemanticEngineCode(),"D3-审核并计算预算标准数据(公共)-D2-生成当前目标内容账单流水业务故事-模板引擎标识不能为空",false);
Assert.isNull(generateBillStreamBizStoryComReqDto.getAccountSubjectName(),"D3-审核并计算预算标准数据(公共)-D2-生成当前目标内容账单流水业务故事-科目名称不能为空",false);
      generateBillStreamBizStoryComRespDto = fwCompTemplateEngineClient.generateBillStreamBizStoryCom(generateBillStreamBizStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤7: D3-执行当前以及祖先账户加减(公共) - implementCurAndParentAccountAddOrSubCom
     ImplementCurAndParentAccountAddOrSubComRespDto implementCurAndParentAccountAddOrSubComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          ImplementCurAndParentAccountAddOrSubComReqDto implementCurAndParentAccountAddOrSubComReqDto=new ImplementCurAndParentAccountAddOrSubComReqDto();
if(reqDto!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1513267_1
implementCurAndParentAccountAddOrSubComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1513268_1
implementCurAndParentAccountAddOrSubComReqDto.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1513269_1
implementCurAndParentAccountAddOrSubComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1513270_1
implementCurAndParentAccountAddOrSubComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1513875_1
implementCurAndParentAccountAddOrSubComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1513876_1
implementCurAndParentAccountAddOrSubComReqDto.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1513878_1
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setCurrentContentCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1513276_1
implementCurAndParentAccountAddOrSubComReqDto.setTargetContentName(omsEvaluationObjectTargetCycle.getCyclelAlias());//SimpleFieldAssign//sourceId:1513278_1
implementCurAndParentAccountAddOrSubComReqDto.setCycleId(omsEvaluationObjectTargetCycle.getCycleId());//SimpleFieldAssign//sourceId:1513877_1
    }
if(queryStandardDataDetailComRespDto!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setBillAmount(queryStandardDataDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1513271_1
    }
if(generateBillStreamBizStoryComRespDto!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setBillBizStory(generateBillStreamBizStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1513272_1
    }
if(queryVirtualOrgChargeInfoDetailComRespDto!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setOppositeName(queryVirtualOrgChargeInfoDetailComRespDto.getIdCardName());//SimpleFieldAssign//sourceId:1513274_1
implementCurAndParentAccountAddOrSubComReqDto.setOppositeLogo(queryVirtualOrgChargeInfoDetailComRespDto.getUserFace());//SimpleFieldAssign//sourceId:1513273_1
    }
if(queryAccountSubjectDetailComRespDto!=null){
      implementCurAndParentAccountAddOrSubComReqDto.setContnetAccountSubjectld(queryAccountSubjectDetailComRespDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1513275_1
implementCurAndParentAccountAddOrSubComReqDto.setAccountSubjectName(queryAccountSubjectDetailComRespDto.getAccountSubjectName());//SimpleFieldAssign//sourceId:1513277_1
    }

    /*D3-执行当前以及祖先账户加减并新增标准数据[8369]   */
    Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getTargetCycleContentTypeCode(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-关联目标内容类型编码不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getTargetCycleContentId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-关联目标内容ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getCurrentContentCode(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-当前内容标识不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getTargetContentName(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-目标内容名称不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getTargetId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-冗余目标ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getEvaluationTemplateId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-冗余评价模板ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getEvaObjTargetCycleId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-被评对象目标周期ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getCycleId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-周期ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getUpdateCycleId(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-更新周期ID不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getBillAmount(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-账单金额不能为空",false);
Assert.isNull(implementCurAndParentAccountAddOrSubComReqDto.getBillBizStory(),"D3-审核并计算预算标准数据(公共)-D3-执行当前以及祖先账户加减并新增标准数据-流水业务故事信息不能为空",false);
      implementCurAndParentAccountAddOrSubComRespDto = targetContentService.implementCurAndParentAccountAddOrSubCom(implementCurAndParentAccountAddOrSubComReqDto)/*vcase invoke isSameApp*/;



           }

ImplementExamineCalcBudgetDataComRespDto retData = new ImplementExamineCalcBudgetDataComRespDto();





return retData;
  }
/**
   * D3-执行预算汇报元素分析(公共)[7697]
   * gen by moon at 3/5/2024, 1:02:01 AM
   */
  @Trace(operationName = "D3-执行预算汇报元素分析(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementBudgetReportElementAnalyzeComRespDto implementBudgetReportElementAnalyzeCom(ImplementBudgetReportElementAnalyzeComReqDto reqDto){


      ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_3 =null;
//virtualUsage D7-查询资金账户详情(公共)  61868
      QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setAccountStatus("NORMAL");//sourceId:1562153_1_61868
queryFinanceAccountDetailComReqDto.setIsBudgetAccount("FALSE");//sourceId:1562146_1_61868
queryFinanceAccountDetailComReqDto.setIsStatisticalAccount("FALSE");//sourceId:1562147_1_61868
queryFinanceAccountDetailComReqDto.setAccountObjectClass("CONTENT_TYPE");//sourceId:1562148_1_61868
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1562151_1_61868
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1562152_1_61868
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1562149_1_61868
    }

    /*D7-查询资金账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountStatus(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-账户状态不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getIsStatisticalAccount(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-是否统计账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectClass(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-账户关联主体分类类型不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3-执行预算汇报元素分析(公共)-D7-查询资金账户详情(公共)-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryFinanceAccountDetailComRespDto!= null&& queryFinanceAccountDetailComRespDto.getAccountId() != null )) {
        //if(D7-查询当前内容是否存在实体账户.账户ID 值不等于空 )  51884

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq.setTureOrFalse("TRUE");//sourceId:1240337_1_51885

    /*约定：是[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTureOrFalse(),"D3-执行预算汇报元素分析(公共)-约定：是-是否不能为空",false);
      receptionServiceRes = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_1=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTargetContentCanReport(receptionServiceRes.getTureOrFalse());//SimpleFieldAssign//sourceId:1240333_1_51886
    }

    /*约定出参：目标内容是否可提交预算[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTargetContentCanReport(),"D3-执行预算汇报元素分析(公共)-约定出参：目标内容是否可提交预算-目标内容是否可提交预算不能为空",false);
      receptionServiceRes_2 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((queryFinanceAccountDetailComRespDto!= null&& queryFinanceAccountDetailComRespDto.getAccountId() == null )){
       //elseif(D7-查询当前内容是否存在实体账户.账户ID 值等于空 )  51887

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_2=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq_2.setTureOrFalse("FALSE");//sourceId:1240338_1_51888

    /*约定：否[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3-执行预算汇报元素分析(公共)-约定：否-是否不能为空",false);
      receptionServiceRes_4 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_3=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setTargetContentCanReport(receptionServiceRes_4.getTureOrFalse());//SimpleFieldAssign//sourceId:1240333_1_51889
    }

    /*约定出参：目标内容是否可提交预算[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTargetContentCanReport(),"D3-执行预算汇报元素分析(公共)-约定出参：目标内容是否可提交预算-目标内容是否可提交预算不能为空",false);
      receptionServiceRes_6 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
    }
ImplementBudgetReportElementAnalyzeComRespDto retData = new ImplementBudgetReportElementAnalyzeComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTargetContentCanReport(receptionServiceRes_3.getTargetContentCanReport());//SimpleFieldAssign//sourceId:1240401_1
    }




return retData;
  }
/**
   * D3-分析目标内容的预算/预算汇报层级(公共)[7698]
   * gen by moon at 11/13/2023, 9:55:37 PM
   */
  @Trace(operationName = "D3-分析目标内容的预算汇报层级(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyzeTargetContentBudgetReportlevelComRespDto implementAnalyzeTargetContentBudgetReportlevelCom(ImplementAnalyzeTargetContentBudgetReportlevelComReqDto reqDto){


      ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_3 =null;
if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET"))) {
        //if(D3-分析目标内容的预算汇报层级(公共).关联目标内容类型编码 等于 目标)  51861

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq.setBudgetReportHierarchy("PLAN_BUDGET");//sourceId:1239909_1_51863

    /*约定：预算在规划[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定：预算在规划-预算汇报层级不能为空",false);
      receptionServiceRes = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_2 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_1=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setBudgetReportHierarchy(receptionServiceRes.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1239823_1_51862
    }

    /*约定出参：预算汇报层级[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定出参：预算汇报层级-预算汇报层级不能为空",false);
      receptionServiceRes_2 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))){
       //elseif(D3-分析目标内容的预算汇报层级(公共).关联目标内容类型编码 等于 目标分类)  51864

OmsTargetCategory omsTargetCategory = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1240143_1_51866
if(reqDto!=null){
      queryTargetCatDetailReq.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1240141_1_51866
queryTargetCatDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1240142_1_51866
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getEvaluationTemplateId(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getSubjectLifeCycle(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-02查目标分类详情-主体生命周期不能为空",false);
      omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategory != null &&omsTargetCategory!= null&& omsTargetCategory.getLevelNumber() == 1L)) {
        //if((3-3-02查目标分类详情.出参 值不等于空  and 3-3-02查目标分类详情.层级 等于 1))  51867

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_4 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_2=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq_2.setBudgetReportHierarchy("PRIMARY_CON_TASK_BUDGET");//sourceId:1240086_1_51868

    /*约定：预算在一级建设任务[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定：预算在一级建设任务-预算汇报层级不能为空",false);
      receptionServiceRes_4 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_2);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_6 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_3=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes_4!=null){
      receptionServiceReq_3.setBudgetReportHierarchy(receptionServiceRes_4.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1239823_1_51869
    }

    /*约定出参：预算汇报层级[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定出参：预算汇报层级-预算汇报层级不能为空",false);
      receptionServiceRes_6 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_6;
      }
else if((omsTargetCategory != null &&omsTargetCategory!= null&&  omsTargetCategory.getIsLast() !=null && omsTargetCategory.getIsLast().equals("TRUE"))){
       //elseif((3-3-02查目标分类详情.出参 值不等于空  and 3-3-02查目标分类详情.目标分类是否末级 等于 是))  51872

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_7 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_4=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq_4.setBudgetReportHierarchy("LAST_CON_TASK_BUDGET");//sourceId:1240092_1_51873

    /*约定：预算在末级建设任务[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定：预算在末级建设任务-预算汇报层级不能为空",false);
      receptionServiceRes_7 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_4);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_9 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_5=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes_7!=null){
      receptionServiceReq_5.setBudgetReportHierarchy(receptionServiceRes_7.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1239823_1_51874
    }

    /*约定出参：预算汇报层级[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定出参：预算汇报层级-预算汇报层级不能为空",false);
      receptionServiceRes_9 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_9;
    }
    }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-分析目标内容的预算汇报层级(公共).关联目标内容类型编码 等于 指标)  51865

OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1240205_1_51875
if(reqDto!=null){
      queryTargetObjDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1240203_1_51875
queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1240204_1_51875
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getSubjectLifeCycle(),"D3-分析目标内容的预算/预算汇报层级(公共)-3-3-03查指标详情-主体生命周期不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjective != null &&omsTargetObjective!= null&& omsTargetObjective.getLevelNumber() == 1L)) {
        //if((3-3-03查指标详情.出参 值不等于空  and 3-3-03查指标详情.层级 等于 1))  51876

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_10 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_6=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq_6.setBudgetReportHierarchy("ONE_LEVEL_OBSERVATION_POINT_BUDGET");//sourceId:1240101_1_51877

    /*约定：预算在一级观测点[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定：预算在一级观测点-预算汇报层级不能为空",false);
      receptionServiceRes_10 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_6);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_12 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_7=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes_10!=null){
      receptionServiceReq_7.setBudgetReportHierarchy(receptionServiceRes_10.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1239823_1_51878
    }

    /*约定出参：预算汇报层级[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定出参：预算汇报层级-预算汇报层级不能为空",false);
      receptionServiceRes_12 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_7);


      receptionServiceRes_3 = receptionServiceRes_12;
      }
else if((omsTargetObjective != null &&omsTargetObjective!= null&&  omsTargetObjective.getIsLastObjective() !=null && omsTargetObjective.getIsLastObjective().equals("TRUE"))){
       //elseif((3-3-03查指标详情.出参 值不等于空  and 3-3-03查指标详情.是否末级指标 等于 是))  51879

//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_13 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_8=new ImplementAcceptFieldByStandardDataReqDto();
  receptionServiceReq_8.setBudgetReportHierarchy("LAST_LEVEL_OBSERVATION_POINT_BUDGET");//sourceId:1240105_1_51880

    /*约定：预算在末级观测点[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定：预算在末级观测点-预算汇报层级不能为空",false);
      receptionServiceRes_13 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_8);



//ModelCode: receptionService
        ImplementAcceptFieldByStandardDataRespDto receptionServiceRes_15 = null;
    ImplementAcceptFieldByStandardDataReqDto receptionServiceReq_9=new ImplementAcceptFieldByStandardDataReqDto();
  if(receptionServiceRes_13!=null){
      receptionServiceReq_9.setBudgetReportHierarchy(receptionServiceRes_13.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1239823_1_51881
    }

    /*约定出参：预算汇报层级[7478]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_9.getBudgetReportHierarchy(),"D3-分析目标内容的预算/预算汇报层级(公共)-约定出参：预算汇报层级-预算汇报层级不能为空",false);
      receptionServiceRes_15 = nbFinance.implementAcceptFieldByStandardData(receptionServiceReq_9);


      receptionServiceRes_3 = receptionServiceRes_15;
    }
    }
ImplementAnalyzeTargetContentBudgetReportlevelComRespDto retData = new ImplementAnalyzeTargetContentBudgetReportlevelComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setBudgetReportHierarchy(receptionServiceRes_3.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1240251_1
    }




return retData;
  }
/**
   * D3-判断预算汇报是否可以提交(公共)[8018]
   * gen by moon at 4/24/2024, 4:11:46 PM
   */
  @Trace(operationName = "D3-判断预算汇报是否可以提交(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public JudgeBudgetReportCanBeSubmitComRespDto judgeBudgetReportCanBeSubmitCom(JudgeBudgetReportCanBeSubmitComReqDto reqDto){


      if((reqDto!= null&& reqDto.getBudgetAmountElement() == 2L&&reqDto!= null&& reqDto.getBudgetDisburse() != null &&reqDto!= null&& reqDto.getBudgetDisburse() >= 0)) {
        //if((D3-判断预算汇报是否可以提交(公共).预算元素 等于 2 and D3-判断预算汇报是否可以提交(公共).预算支出金额 值不等于空  and D3-判断预算汇报是否可以提交(公共).预算支出金额 大于等于 0))  61897

ImplementSubmitBudgetAnalyzeComRespDto implementSubmitBudgetAnalyzeComRespDto = null;
          ImplementSubmitBudgetAnalyzeComReqDto implementSubmitBudgetAnalyzeComReqDto=new ImplementSubmitBudgetAnalyzeComReqDto();
  if(reqDto!=null){
      implementSubmitBudgetAnalyzeComReqDto.setBudgetDisburse(reqDto.getBudgetDisburse());//SimpleFieldAssign//sourceId:1562164_1_61898
implementSubmitBudgetAnalyzeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1562160_1_61898
implementSubmitBudgetAnalyzeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1562523_1_61898
    }

    /*D3-执行提交预算条件分析(公共)[7704]   */
    Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getBudgetDisburse(),"D3-判断预算汇报是否可以提交(公共)-D3-执行提交预算条件分析(公共)-预算支出金额不能为空",false);
Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getTargetCycleContentId(),"D3-判断预算汇报是否可以提交(公共)-D3-执行提交预算条件分析(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementSubmitBudgetAnalyzeComReqDto.getEvaluationTemplateId(),"D3-判断预算汇报是否可以提交(公共)-D3-执行提交预算条件分析(公共)-冗余评价模板ID不能为空",false);
      implementSubmitBudgetAnalyzeComRespDto = implementSubmitBudgetAnalyzeCom(implementSubmitBudgetAnalyzeComReqDto)/*vcase invoke 同服务,同domain*/;



      }
JudgeBudgetReportCanBeSubmitComRespDto retData = new JudgeBudgetReportCanBeSubmitComRespDto();





return retData;
  }
/**
   * D3-查询可用财务科目列表(公共)[8021]
   * gen by moon at 3/15/2024, 9:08:47 PM
   */
  @Trace(operationName = "D3-查询可用财务科目列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryUsableAccountSubjectListComRespDto queryUsableAccountSubjectListCom(QueryUsableAccountSubjectListComReqDto reqDto){


      QueryAccountSubjectListComRespDto queryAccountSubjectListComRespDto_1 =null;
//virtualUsage D2-3查评价主题启用的财务科目类型  63000
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("USE_ACCOUNT_SUBJECT_TYPE");//CUSTOM_CONVENTION//sourceId:1351591_1_63000
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1351592_1_63000
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1351589_1_63000
    }

    /*D2-3查评价主题启用的财务科目类型[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-查询可用财务科目列表(公共)-D2-3查评价主题启用的财务科目类型-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-查询可用财务科目列表(公共)-D2-3查评价主题启用的财务科目类型-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-查询可用财务科目列表(公共)-D2-3查评价主题启用的财务科目类型-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryConfItemMatchAnswerDetailComRespDto!= null&& queryConfItemMatchAnswerDetailComRespDto.getEndValue() != null )) {
        //if(D2-3查评价主题启用的财务科目类型.答案值 值不等于空 )  63001

QueryAccountSubjectListComRespDto queryAccountSubjectListComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto !=null){
          QueryAccountSubjectListComReqDto queryAccountSubjectListComReqDto=new QueryAccountSubjectListComReqDto();
  queryAccountSubjectListComReqDto.setIncomeExpensesType("SPENDING");//sourceId:1351595_1_63002
queryAccountSubjectListComReqDto.setBehaviorTypeCode("CHARGE_EXPENDITURE");//sourceId:1562353_1_63002
queryAccountSubjectListComReqDto.setAccountSubjectClassCode("ENTITY_ACCOUNT_CLASS");//sourceId:1351596_1_63002
queryAccountSubjectListComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1351598_1_63002
if(queryConfItemMatchAnswerDetailComRespDto!=null){
      queryAccountSubjectListComReqDto.setAccountSubjectType(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1351594_1_63002
    }

    /*D7-查询财务科目列表(公共)[7712]   */
    Assert.isNull(queryAccountSubjectListComReqDto.getAccountSubjectType(),"D3-查询可用财务科目列表(公共)-D7-查询财务科目列表(公共)-科目类型不能为空",false);
Assert.isNull(queryAccountSubjectListComReqDto.getIncomeExpensesType(),"D3-查询可用财务科目列表(公共)-D7-查询财务科目列表(公共)-收支类型不能为空",false);
Assert.isNull(queryAccountSubjectListComReqDto.getBehaviorTypeCode(),"D3-查询可用财务科目列表(公共)-D7-查询财务科目列表(公共)-行为类型编码不能为空",false);
Assert.isNull(queryAccountSubjectListComReqDto.getAccountSubjectClassCode(),"D3-查询可用财务科目列表(公共)-D7-查询财务科目列表(公共)-科目类别编码不能为空",false);
Assert.isNull(queryAccountSubjectListComReqDto.getSubjectLifeCycle(),"D3-查询可用财务科目列表(公共)-D7-查询财务科目列表(公共)-主体生命周期不能为空",false);
      queryAccountSubjectListComRespDto = fwFinanceFinanceClient.queryAccountSubjectListCom(queryAccountSubjectListComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryAccountSubjectListComRespDto_1 = queryAccountSubjectListComRespDto;
           }
      }
QueryUsableAccountSubjectListComRespDto retData = new QueryUsableAccountSubjectListComRespDto();
  if(queryAccountSubjectListComRespDto_1!=null){
      retData.setAccountSubjectList(queryAccountSubjectListComRespDto_1.getAccountSubjectList().stream().map(item -> BeanUtil.toBean(item, AccountSubjectDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1351604_1
    }




return retData;
  }
/**
   * D3-执行目标预算设置(公共)[8385]
   * gen by moon at 2/19/2024, 12:38:21 PM
   */
  @Trace(operationName = "D3-执行目标预算设置(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementTargetBudgetSetComRespDto implementTargetBudgetSetCom(ImplementTargetBudgetSetComReqDto reqDto){


      //步骤0: M3执行接收字段入参（特殊方法） - implementAcceptField
     //ModelCode: receptionService
        ImplementAcceptFieldRespDto receptionServiceRes = null;
    ImplementAcceptFieldReqDto receptionServiceReq=new ImplementAcceptFieldReqDto();
  if(reqDto!= null&&  reqDto.getTargetBudgetSetList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetBudgetSetList())){
      receptionServiceReq.setTargetBudgetSetList(reqDto.getTargetBudgetSetList().stream().map(item -> BeanUtil.toBean(item, TargetBudgetSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1524423_1
    }
if(reqDto!=null){
      receptionServiceReq.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1524409_1
receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1524410_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1524411_1
receptionServiceReq.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1524425_1
receptionServiceReq.setAddOrSubOptType(reqDto.getAddOrSubOptType());//SimpleFieldAssign//sourceId:1524427_1
    }

    /*M3接收字段[6100]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentTypeCode(),"D3-执行目标预算设置(公共)-M3接收字段-关联目标内容类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3-执行目标预算设置(公共)-M3接收字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3-执行目标预算设置(公共)-M3接收字段-冗余评价模板ID不能为空",false);
Assert.isNull(receptionServiceReq.getPeriodicModeTypeCode(),"D3-执行目标预算设置(公共)-M3接收字段-周期模式类型编码不能为空",false);
Assert.isNull(receptionServiceReq.getAddOrSubOptType(),"D3-执行目标预算设置(公共)-M3接收字段-加减操作类型不能为空",false);
      receptionServiceRes = nbFinance.implementAcceptField(receptionServiceReq);




//步骤1: D3执行预算设置目标周期准备(公共) - implementBudgetSetTargetCycleEquippCom
     ImplementBudgetSetTargetCycleEquippComRespDto implementBudgetSetTargetCycleEquippComRespDto = null;
    ImplementBudgetSetTargetCycleEquippComReqDto implementBudgetSetTargetCycleEquippComReqDto=new ImplementBudgetSetTargetCycleEquippComReqDto();
  if(reqDto!=null){
      implementBudgetSetTargetCycleEquippComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1523378_1
implementBudgetSetTargetCycleEquippComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1523379_1
    }

    /*D3执行预算设置目标周期准备(公共)[8430]   */
    Assert.isNull(implementBudgetSetTargetCycleEquippComReqDto.getTargetCycleContentId(),"D3-执行目标预算设置(公共)-D3执行预算设置目标周期准备(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementBudgetSetTargetCycleEquippComReqDto.getEvaluationTemplateId(),"D3-执行目标预算设置(公共)-D3执行预算设置目标周期准备(公共)-冗余评价模板ID不能为空",false);
      implementBudgetSetTargetCycleEquippComRespDto = targetContentService.implementBudgetSetTargetCycleEquippCom(implementBudgetSetTargetCycleEquippComReqDto)/*vcase invoke isSameApp*/;




//步骤2: D2分析账单流水业务故事(公共) - analysisBillStreamBizStoryCom
     AnalysisBillStreamBizStoryComRespDto analysisBillStreamBizStoryComRespDto = null;
    if(implementBudgetSetTargetCycleEquippComRespDto !=null){
          AnalysisBillStreamBizStoryComReqDto analysisBillStreamBizStoryComReqDto=new AnalysisBillStreamBizStoryComReqDto();
  if(reqDto!=null){
      analysisBillStreamBizStoryComReqDto.setAddOrSubOptType(reqDto.getAddOrSubOptType());//SimpleFieldAssign//sourceId:1524456_1
    }
if(implementBudgetSetTargetCycleEquippComRespDto!=null){
      analysisBillStreamBizStoryComReqDto.setFirstFieldValue(implementBudgetSetTargetCycleEquippComRespDto.getCyclelAlias());//SimpleFieldAssign//sourceId:1524457_1
    }

    /*D2分析账单流水业务故事(公共)[8431]   */
    Assert.isNull(analysisBillStreamBizStoryComReqDto.getAddOrSubOptType(),"D3-执行目标预算设置(公共)-D2分析账单流水业务故事(公共)-加减操作类型不能为空",false);
Assert.isNull(analysisBillStreamBizStoryComReqDto.getFirstFieldValue(),"D3-执行目标预算设置(公共)-D2分析账单流水业务故事(公共)-第一个字段字段值不能为空",false);
      analysisBillStreamBizStoryComRespDto = fwCompTemplateEngineClient.analysisBillStreamBizStoryCom(analysisBillStreamBizStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤3: D1查询空间信息详情(公共) - querySpaceInfoDetailCom
     QuerySpaceInfoDetailComRespDto querySpaceInfoDetailComRespDto = null;
    QuerySpaceInfoDetailComReqDto querySpaceInfoDetailComReqDto=new QuerySpaceInfoDetailComReqDto();
  querySpaceInfoDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1522352_1

    /*D1查询空间logo、空间名称[5423]   */
    Assert.isNull(querySpaceInfoDetailComReqDto.getSpaceId(),"D3-执行目标预算设置(公共)-D1查询空间logo、空间名称-空间ID不能为空",false);
      querySpaceInfoDetailComRespDto = fwBaseBaseClient.querySpaceInfoDetailCom(querySpaceInfoDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: D7-执行目标财务预算相关处理(公共) - implementTargetFinBudgetHandleCom
     ImplementTargetFinBudgetHandleComRespDto implementTargetFinBudgetHandleComRespDto = null;
    if(implementBudgetSetTargetCycleEquippComRespDto !=null){
          ImplementTargetFinBudgetHandleComReqDto implementTargetFinBudgetHandleComReqDto=new ImplementTargetFinBudgetHandleComReqDto();
  if(reqDto!= null&&  reqDto.getTargetBudgetSetList() !=null&& !CollectionUtil.isEmpty(reqDto.getTargetBudgetSetList())){
      implementTargetFinBudgetHandleComReqDto.setTargetBudgetSetList(reqDto.getTargetBudgetSetList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrfinance.integration.dto.TargetBudgetSetDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1521539_1
    }
if(implementBudgetSetTargetCycleEquippComRespDto!=null){
      implementTargetFinBudgetHandleComReqDto.setSubCycleList(implementBudgetSetTargetCycleEquippComRespDto.getSubCycleList());//list-field-assign//sourceId:1521540_1
implementTargetFinBudgetHandleComReqDto.setMidTermSubCycleList(implementBudgetSetTargetCycleEquippComRespDto.getMidTermSubCycleList());//list-field-assign//sourceId:1521541_1
implementTargetFinBudgetHandleComReqDto.setEvaObjTargetCycleCode(implementBudgetSetTargetCycleEquippComRespDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1521552_1
implementTargetFinBudgetHandleComReqDto.setParentEvaObjTargetCycleId(implementBudgetSetTargetCycleEquippComRespDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1555064_1
implementTargetFinBudgetHandleComReqDto.setFatherEvaObjTargetCycleId(implementBudgetSetTargetCycleEquippComRespDto.getFatherEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1521544_1
implementTargetFinBudgetHandleComReqDto.setMidEvaObjTargetCycleId(implementBudgetSetTargetCycleEquippComRespDto.getMidEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1521545_1
    }
if(reqDto!=null){
      implementTargetFinBudgetHandleComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1521543_1
implementTargetFinBudgetHandleComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1521542_1
implementTargetFinBudgetHandleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1521546_1
implementTargetFinBudgetHandleComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1521547_1
implementTargetFinBudgetHandleComReqDto.setAddOrSubOptType(reqDto.getAddOrSubOptType());//SimpleFieldAssign//sourceId:1521548_1
    }
if(querySpaceInfoDetailComRespDto!=null){
      implementTargetFinBudgetHandleComReqDto.setOppositeLogo(querySpaceInfoDetailComRespDto.getSpaceLogo());//SimpleFieldAssign//sourceId:1521549_1
implementTargetFinBudgetHandleComReqDto.setOppositeName(querySpaceInfoDetailComRespDto.getAbbreviation());//SimpleFieldAssign//sourceId:1521550_1
    }
if(analysisBillStreamBizStoryComRespDto!=null){
      implementTargetFinBudgetHandleComReqDto.setBillBizStory(analysisBillStreamBizStoryComRespDto.getObjectName());//SimpleFieldAssign//sourceId:1521551_1
    }

    /*D7-执行目标财务预算相关处理(公共)[8409]   */
    Assert.isNull(implementTargetFinBudgetHandleComReqDto.getTargetCycleContentTypeCode(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getTargetCycleContentId(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getEvaObjTargetCycleCode(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getFatherEvaObjTargetCycleId(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-父周期被评对象目标周期ID不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getEvaluationTemplateId(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-评价模板ID不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getPeriodicModeTypeCode(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getAddOrSubOptType(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-加减操作类型不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getOppositeLogo(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-对方logo不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getOppositeName(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-对方名称不能为空",false);
Assert.isNull(implementTargetFinBudgetHandleComReqDto.getBillBizStory(),"D3-执行目标预算设置(公共)-D7-执行目标财务预算相关处理(公共)-流水业务故事信息不能为空",false);
      implementTargetFinBudgetHandleComRespDto = fwFinanceFinanceClient.implementTargetFinBudgetHandleCom(implementTargetFinBudgetHandleComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }

ImplementTargetBudgetSetComRespDto retData = new ImplementTargetBudgetSetComRespDto();





return retData;
  }
/**
   * D3查询目标内容父周期预算设置详情[8382]
   * gen by moon at 2/29/2024, 1:02:43 AM
   */
  @Trace(operationName = "D3查询目标内容父周期预算设置详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetParentCycleBudgetSetDetailRespDto queryTargetParentCycleBudgetSetDetail(QueryTargetParentCycleBudgetSetDetailReqDto reqDto){


      OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle_1 =null;
QueryTargetBudgetSetDetailComRespDto queryTargetBudgetSetDetailComRespDto_1 =null;
QueryTargetContentBudgetStateDetailComRespDto queryTargetContentBudgetStateDetailComRespDto_1 =null;
//virtualUsage M3约定父周期或子周期  61843
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("PARENT_CYCLE");//CUSTOM_CONVENTION//sourceId:1561500_1_61843
receptionServiceReq.setCustomField2("SUB_CYCLE");//CUSTOM_CONVENTION//sourceId:1561501_1_61843

    /*M3约定父周期或子周期[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3查询目标内容父周期预算设置详情-M3约定父周期或子周期-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3查询目标内容父周期预算设置详情-M3约定父周期或子周期-自定义字段2不能为空",false);
      receptionServiceRes = nbFinance.implementFiveReceivingField(receptionServiceReq);



//virtualUsage 3-3-09查被评对象目标父周期详情  61837
     OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setTreeTypeCode("PLAN_TREE");//sourceId:1560786_1_61837
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1560790_1_61837
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1560791_1_61837
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1560787_1_61837
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1560788_1_61837
    }

    /*3-3-09查被评对象目标父周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getTreeTypeCode(),"D3查询目标内容父周期预算设置详情-3-3-09查被评对象目标父周期详情-树类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3查询目标内容父周期预算设置详情-3-3-09查被评对象目标父周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3查询目标内容父周期预算设置详情-3-3-09查被评对象目标父周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3查询目标内容父周期预算设置详情-3-3-09查被评对象目标父周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3查询目标内容父周期预算设置详情-3-3-09查被评对象目标父周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId() ==null,"找不到数据，系统异常",false);

      omsEvaluationObjectTargetCycle_1 = omsEvaluationObjectTargetCycle;
if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("FATHER_SON_CYCLE"))) {
        //if(D3查询目标内容父周期预算设置详情.周期模式类型编码 等于 父子周期)  61838

     QueryTargetBudgetSetDetailComRespDto queryTargetBudgetSetDetailComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryTargetBudgetSetDetailComReqDto queryTargetBudgetSetDetailComReqDto=new QueryTargetBudgetSetDetailComReqDto();
  queryTargetBudgetSetDetailComReqDto.setIsArchive("FALSE");//sourceId:1528342_1_61840
queryTargetBudgetSetDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1528351_1_61840
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetBudgetSetDetailComReqDto.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1528339_1_61840
    }
if(reqDto!=null){
      queryTargetBudgetSetDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1528341_1_61840
    }
if(receptionServiceRes!=null){
      queryTargetBudgetSetDetailComReqDto.setBudgetCycleModeTypeCode(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1528338_1_61840
    }

    /*D7查询目标预算设置详情[8450]   */
    Assert.isNull(queryTargetBudgetSetDetailComReqDto.getEvaObjTargetCycleId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto.getEvaluationTemplateId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto.getBudgetCycleModeTypeCode(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-预算周期模型编码不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto.getIsArchive(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-是否存档不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto.getSpaceId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-创建于空间ID不能为空",false);
      queryTargetBudgetSetDetailComRespDto = fwFinanceFinanceClient.queryTargetBudgetSetDetailCom(queryTargetBudgetSetDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryTargetBudgetSetDetailComRespDto_1 = queryTargetBudgetSetDetailComRespDto;
           }
      }
else if((reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("SINGLE_CYCLE")||reqDto!= null&&  reqDto.getPeriodicModeTypeCode() !=null && reqDto.getPeriodicModeTypeCode().equals("IRREGULAR_CYCLE"))){
       //elseif((D3查询目标内容父周期预算设置详情.周期模式类型编码 等于 单周期 or D3查询目标内容父周期预算设置详情.周期模式类型编码 等于 不规则周期))  61839

QueryTargetBudgetSetDetailComRespDto queryTargetBudgetSetDetailComRespDto_2 = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryTargetBudgetSetDetailComReqDto queryTargetBudgetSetDetailComReqDto_1=new QueryTargetBudgetSetDetailComReqDto();
  queryTargetBudgetSetDetailComReqDto_1.setIsArchive("FALSE");//sourceId:1528342_1_61842
queryTargetBudgetSetDetailComReqDto_1.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1528351_1_61842
if(omsEvaluationObjectTargetCycle!=null){
      queryTargetBudgetSetDetailComReqDto_1.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1528339_1_61842
    }
if(reqDto!=null){
      queryTargetBudgetSetDetailComReqDto_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1528341_1_61842
    }
if(receptionServiceRes!=null){
      queryTargetBudgetSetDetailComReqDto_1.setBudgetCycleModeTypeCode(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1528338_1_61842
    }

    /*D7查询目标预算设置详情[8450]   */
    Assert.isNull(queryTargetBudgetSetDetailComReqDto_1.getEvaObjTargetCycleId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto_1.getEvaluationTemplateId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto_1.getBudgetCycleModeTypeCode(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-预算周期模型编码不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto_1.getIsArchive(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-是否存档不能为空",false);
Assert.isNull(queryTargetBudgetSetDetailComReqDto_1.getSpaceId(),"D3查询目标内容父周期预算设置详情-D7查询目标预算设置详情-创建于空间ID不能为空",false);
      queryTargetBudgetSetDetailComRespDto_2 = fwFinanceFinanceClient.queryTargetBudgetSetDetailCom(queryTargetBudgetSetDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryTargetBudgetSetDetailComRespDto_1 = queryTargetBudgetSetDetailComRespDto_2;
           }
    }
//virtualUsage D3执行内容类型互转表类型(公共)  61844
     ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1560691_1_61844
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3查询目标内容父周期预算设置详情-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3查询目标内容预算设置状态详情(公共)  61845
     QueryTargetContentBudgetStateDetailComRespDto queryTargetContentBudgetStateDetailComRespDto = null;
    if(implementContentTypeChangeTableTypeComRespDto !=null){
          QueryTargetContentBudgetStateDetailComReqDto queryTargetContentBudgetStateDetailComReqDto=new QueryTargetContentBudgetStateDetailComReqDto();
  if(implementContentTypeChangeTableTypeComRespDto!=null){
      queryTargetContentBudgetStateDetailComReqDto.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1560687_1_61845
    }
if(reqDto!=null){
      queryTargetContentBudgetStateDetailComReqDto.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1560688_1_61845
queryTargetContentBudgetStateDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1560689_1_61845
    }

    /*D3查询目标内容预算设置状态详情(公共)[2859]   */
    Assert.isNull(queryTargetContentBudgetStateDetailComReqDto.getTableTypeCode(),"D3查询目标内容父周期预算设置详情-D3查询目标内容预算设置状态详情(公共)-内容表类型编码不能为空",false);
Assert.isNull(queryTargetContentBudgetStateDetailComReqDto.getEntityId(),"D3查询目标内容父周期预算设置详情-D3查询目标内容预算设置状态详情(公共)-内容表主键ID不能为空",false);
Assert.isNull(queryTargetContentBudgetStateDetailComReqDto.getEvaluationTemplateId(),"D3查询目标内容父周期预算设置详情-D3查询目标内容预算设置状态详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetContentBudgetStateDetailComRespDto = queryTargetContentBudgetStateDetailCom(queryTargetContentBudgetStateDetailComReqDto)/*vcase invoke 同服务,同domain*/;


      queryTargetContentBudgetStateDetailComRespDto_1 = queryTargetContentBudgetStateDetailComRespDto;
           }

QueryTargetParentCycleBudgetSetDetailRespDto retData = new QueryTargetParentCycleBudgetSetDetailRespDto();
  if(queryTargetBudgetSetDetailComRespDto_1!=null){
      retData.setTargetCostSetId(queryTargetBudgetSetDetailComRespDto_1.getTargetCostSetId());//SimpleFieldAssign//sourceId:1528352_1
retData.setEvaObjTargetCycleId(queryTargetBudgetSetDetailComRespDto_1.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1528353_1
retData.setCycleBudgetAmount(queryTargetBudgetSetDetailComRespDto_1.getCycleBudgetAmount());//SimpleFieldAssign//sourceId:1528354_1
retData.setCycleBudgetUnit(queryTargetBudgetSetDetailComRespDto_1.getCycleBudgetUnit());//SimpleFieldAssign//sourceId:1528355_1
retData.setIsBudgetSeted(queryTargetBudgetSetDetailComRespDto_1.getIsBudgetSeted());//SimpleFieldAssign//sourceId:1560702_1
    }
if(queryTargetContentBudgetStateDetailComRespDto_1!=null){
      retData.setIsOpenBudget(queryTargetContentBudgetStateDetailComRespDto_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1560695_1
    }
if(omsEvaluationObjectTargetCycle_1!=null){
      retData.setSubjectLifeCycle(omsEvaluationObjectTargetCycle_1.getSubjectLifeCycle());//SimpleFieldAssign//sourceId:1560794_1
retData.setTargetCycleName(omsEvaluationObjectTargetCycle_1.getTargetCycleName());//SimpleFieldAssign//sourceId:1560832_1
    }




return retData;
  }
/**
   * D3查询目标周期及来源预算设置列表[8455]
   * gen by moon at 2/18/2024, 1:23:05 PM
   */
  @Trace(operationName = "D3查询目标周期及来源预算设置列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetCycleAndSourceBudgetSetListRespDto queryTargetCycleAndSourceBudgetSetList(QueryTargetCycleAndSourceBudgetSetListReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
BatchQueryTargetCycleAndSourceBudgetSetComRespDto batchQueryTargetCycleAndSourceBudgetSetComRespDto_1 =null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
     //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1530149_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1530148_1
    }

    /*M3接收字段[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3查询目标周期及来源预算设置列表-M3接收字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标周期及来源预算设置列表-M3接收字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbFinance.obtainReceiveOutField(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1529413_1
queryEvaObjTargetCycleListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1529414_1
queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1529416_1
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1529418_1
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1529415_1
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1529417_1
    }

    /*3-3-09查当前内容目标子周期列表（用于查询资源预算）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3查询目标周期及来源预算设置列表-3-3-09查当前内容目标子周期列表（用于查询资源预算）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

//步骤2: D7批量查询目标周期及来源预算设置(公共) - batchQueryTargetCycleAndSourceBudgetSetCom
     BatchQueryTargetCycleAndSourceBudgetSetComRespDto batchQueryTargetCycleAndSourceBudgetSetComRespDto = null;
          BatchQueryTargetCycleAndSourceBudgetSetComReqDto batchQueryTargetCycleAndSourceBudgetSetComReqDto=new BatchQueryTargetCycleAndSourceBudgetSetComReqDto();
  batchQueryTargetCycleAndSourceBudgetSetComReqDto.setIsBudgetSeted("TRUE");//sourceId:1529810_1
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryTargetCycleAndSourceBudgetSetComReqDto.setTargetBudgetSetList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1529813_1
    }
if(reqDto!=null){
      batchQueryTargetCycleAndSourceBudgetSetComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1529811_1
batchQueryTargetCycleAndSourceBudgetSetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1529812_1
    }

    /*D7批量查询目标周期及来源预算设置(公共)[8457]   */
    Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getIsBudgetSeted(),"D3查询目标周期及来源预算设置列表-D7批量查询目标周期及来源预算设置(公共)-预算是否已设置不能为空",false);
Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getTargetCycleContentId(),"D3查询目标周期及来源预算设置列表-D7批量查询目标周期及来源预算设置(公共)-关联目标内容ID不能为空",false);
Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getEvaluationTemplateId(),"D3查询目标周期及来源预算设置列表-D7批量查询目标周期及来源预算设置(公共)-评价模板ID不能为空",false);
      batchQueryTargetCycleAndSourceBudgetSetComRespDto = fwFinanceFinanceClient.batchQueryTargetCycleAndSourceBudgetSetCom(batchQueryTargetCycleAndSourceBudgetSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryTargetCycleAndSourceBudgetSetComRespDto_1 = batchQueryTargetCycleAndSourceBudgetSetComRespDto;

QueryTargetCycleAndSourceBudgetSetListRespDto retData = new QueryTargetCycleAndSourceBudgetSetListRespDto();
  //数据集融合  MoreListToOneSource
        if(batchQueryTargetCycleAndSourceBudgetSetComRespDto_1!= null && !CollectionUtil.isEmpty(batchQueryTargetCycleAndSourceBudgetSetComRespDto_1.getTargetBudgetSetList()) ){
          for (com.wicket.okrfinance.integration.dto.TargetBudgetSetDto targetBudgetSetDto : batchQueryTargetCycleAndSourceBudgetSetComRespDto_1.getTargetBudgetSetList()) {
              TargetBudgetSetDto retElm = new TargetBudgetSetDto();
                 if(batchQueryTargetCycleAndSourceBudgetSetComRespDto_1!=null){
      retElm.setTargetCostSetId(targetBudgetSetDto.getTargetCostSetId());//SimpleFieldAssign//sourceId:300012_2
retElm.setCycleBudgetAmount(targetBudgetSetDto.getCycleBudgetAmount());//SimpleFieldAssign//sourceId:300013_2
retElm.setCycleBudgetUnit(targetBudgetSetDto.getCycleBudgetUnit());//SimpleFieldAssign//sourceId:300014_2
retElm.setBudgetRate(targetBudgetSetDto.getBudgetRate());//SimpleFieldAssign//sourceId:300015_2
retElm.setCapitalSourceId(targetBudgetSetDto.getCapitalSourceId());//SimpleFieldAssign//sourceId:300016_2
retElm.setCapitalSourceName(targetBudgetSetDto.getCapitalSourceName());//SimpleFieldAssign//sourceId:300017_2
    }
              retData.getTargetBudgetSetList().add(retElm);
               if(listOmsEvaluationObjectTargetCycle_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1)){
          for (OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle : listOmsEvaluationObjectTargetCycle_1) {
                if (omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId().equals(targetBudgetSetDto.getEvaObjTargetCycleId())) {
                 retElm.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:300010_2
retElm.setCycleStandardName(omsEvaluationObjectTargetCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:300011_2
                }
            }
          }

          }
        }//sourceId:1530269_1




return retData;
  }
/**
   * D3查询目标周期预算设置资金来源列表[8460]
   * gen by moon at 2/5/2024, 7:10:36 PM
   */
  @Trace(operationName = "D3查询目标周期预算设置资金来源列表")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetCycleBudgetSetSourceListRespDto queryTargetCycleBudgetSetSourceList(QueryTargetCycleBudgetSetSourceListReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
BatchQueryTargetCycleAndSourceBudgetSetComRespDto batchQueryTargetCycleAndSourceBudgetSetComRespDto_1 =null;
//步骤0: M3接收外部字段(特殊方法） - obtainReceiveOutField
     //ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq=new ObtainReceiveOutFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1531626_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1531627_1
    }

    /*M3接收字段[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getTargetCycleContentId(),"D3查询目标周期预算设置资金来源列表-M3接收字段-关联目标内容ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3查询目标周期预算设置资金来源列表-M3接收字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbFinance.obtainReceiveOutField(receptionServiceReq);




//步骤1: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1530902_1
queryEvaObjTargetCycleListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1530903_1
queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1530905_1
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1530907_1
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1530904_1
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1530906_1
    }

    /*3-3-09查当前目标内容子周期列表[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjEntityId(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3查询目标周期预算设置资金来源列表-3-3-09查当前目标内容子周期列表-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

//步骤2: D7批量查询目标周期及来源预算设置(公共) - batchQueryTargetCycleAndSourceBudgetSetCom
     BatchQueryTargetCycleAndSourceBudgetSetComRespDto batchQueryTargetCycleAndSourceBudgetSetComRespDto = null;
    if(listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&& listOmsEvaluationObjectTargetCycle.size()>0 ){
          BatchQueryTargetCycleAndSourceBudgetSetComReqDto batchQueryTargetCycleAndSourceBudgetSetComReqDto=new BatchQueryTargetCycleAndSourceBudgetSetComReqDto();
  //batchQueryTargetCycleAndSourceBudgetSetComReqDto.setBudgetCycleModeTypeCode("CAPITAL_SOURCE");//sourceId:1532478_1
if(listOmsEvaluationObjectTargetCycle!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)&&  listOmsEvaluationObjectTargetCycle !=null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle)){
      batchQueryTargetCycleAndSourceBudgetSetComReqDto.setTargetBudgetSetList(listOmsEvaluationObjectTargetCycle.stream().map(item->item.getEvaObjTargetCycleId())
        .collect(Collectors.toList()));/*list-to-strings*///sourceId:1532399_1
    }
if(reqDto!=null){
      batchQueryTargetCycleAndSourceBudgetSetComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1532397_1
batchQueryTargetCycleAndSourceBudgetSetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1532398_1
    }

    /*D7批量查询目标周期及来源预算设置(公共)[8457]   */
    //Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getBudgetCycleModeTypeCode(),"D3查询目标周期预算设置资金来源列表-D7批量查询目标周期及来源预算设置(公共)-预算周期模型编码不能为空",false);
Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getTargetCycleContentId(),"D3查询目标周期预算设置资金来源列表-D7批量查询目标周期及来源预算设置(公共)-关联目标内容ID不能为空",false);
Assert.isNull(batchQueryTargetCycleAndSourceBudgetSetComReqDto.getEvaluationTemplateId(),"D3查询目标周期预算设置资金来源列表-D7批量查询目标周期及来源预算设置(公共)-评价模板ID不能为空",false);
      batchQueryTargetCycleAndSourceBudgetSetComRespDto = fwFinanceFinanceClient.batchQueryTargetCycleAndSourceBudgetSetCom(batchQueryTargetCycleAndSourceBudgetSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      batchQueryTargetCycleAndSourceBudgetSetComRespDto_1 = batchQueryTargetCycleAndSourceBudgetSetComRespDto;
           }

QueryTargetCycleBudgetSetSourceListRespDto retData = new QueryTargetCycleBudgetSetSourceListRespDto();
  //数据集融合  MoreListToOneSource
        if(listOmsEvaluationObjectTargetCycle_1!= null&& !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1) && !CollectionUtil.isEmpty(listOmsEvaluationObjectTargetCycle_1) ){
          for (OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle : listOmsEvaluationObjectTargetCycle_1) {
              TargetBudgetSetDto retElm = new TargetBudgetSetDto();
             retElm.setEvaObjTargetCycleId(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:300345_2
retElm.setCycleStandardName(omsEvaluationObjectTargetCycle.getCycleStandardName());//SimpleFieldAssign//sourceId:300346_2
              retData.getTargetBudgetSetList().add(retElm);
               if(batchQueryTargetCycleAndSourceBudgetSetComRespDto_1!= null){
          for (com.wicket.okrfinance.integration.dto.TargetBudgetSetDto targetBudgetSetDto : batchQueryTargetCycleAndSourceBudgetSetComRespDto_1.getTargetBudgetSetList()) {
                if (targetBudgetSetDto.getEvaObjTargetCycleId().equals(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleId())) {
                 if(batchQueryTargetCycleAndSourceBudgetSetComRespDto_1!=null){
      retElm.setTargetCostSetId(targetBudgetSetDto.getTargetCostSetId());//SimpleFieldAssign//sourceId:300347_2
retElm.setCycleBudgetUnit(targetBudgetSetDto.getCycleBudgetUnit());//SimpleFieldAssign//sourceId:300348_2
retElm.setCapitalSourceId(targetBudgetSetDto.getCapitalSourceId());//SimpleFieldAssign//sourceId:300349_2
retElm.setCapitalSourceName(targetBudgetSetDto.getCapitalSourceName());//SimpleFieldAssign//sourceId:300350_2
    }
                }
            }
          }

          }
        }//sourceId:1532416_1




return retData;
  }
/**
   * D3执行全内容统计资金来源及账户(公共)[8412]
   * gen by moon at 5/28/2024, 11:48:31 AM
   */
  @Trace(operationName = "D3执行全内容统计资金来源及账户(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAllContentCountFundingSourcesAccountsComRespDto implementAllContentCountFundingSourcesAccountsCom(ImplementAllContentCountFundingSourcesAccountsComReqDto reqDto){


      //virtualUsage D2-3准备数据：1是否开启财务  60569
      QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1520711_1_60569
queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_FINANCE");//CUSTOM_CONVENTION//sourceId:1520712_1_60569
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1520713_1_60569

    /*D2-3准备数据：1是否开启财务[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：1是否开启财务-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：1是否开启财务-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：1是否开启财务-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto== null||  queryConfItemMatchAnswerDetailComRespDto.getEndValue() ==null,"找不到数据，系统异常",false);


//virtualUsage 3-3-01准备数据：2周期模式类型编码  61616
OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  if(reqDto!=null){
      queryTargetDetailReq.setTargetId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1520634_1_61616
queryTargetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1520627_1_61616
    }

    /*3-3-01准备数据：2周期模式类型编码[2488]   */
    Assert.isNull(queryTargetDetailReq.getTargetId(),"D3执行全内容统计资金来源及账户(公共)-3-3-01准备数据：2周期模式类型编码-目标ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-3-3-01准备数据：2周期模式类型编码-归属评价模板ID不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTarget== null||  omsTarget.getPeriodicModeTypeCode() ==null,"找不到数据，系统异常",false);


//virtualUsage D2-3准备数据：3是否开启预算  61615
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    if(omsTarget !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("IS_OPEN_BUDGET");//CUSTOM_CONVENTION//sourceId:1520766_1_61615
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1520767_1_61615
if(omsTarget!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(omsTarget.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1520765_1_61615
    }

    /*D2-3准备数据：3是否开启预算[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：3是否开启预算-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：3是否开启预算-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：3是否开启预算-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto_2== null||  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() ==null,"找不到数据，系统异常",false);


           }
if((queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("OPEN_CHARGE")||queryConfItemMatchAnswerDetailComRespDto!= null&&  queryConfItemMatchAnswerDetailComRespDto.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto.getEndValue().equals("OPEN_FINANCE"))&&(queryConfItemMatchAnswerDetailComRespDto_2!= null&&  queryConfItemMatchAnswerDetailComRespDto_2.getEndValue() !=null && queryConfItemMatchAnswerDetailComRespDto_2.getEndValue().equals("TRUE"))) {
        //if((D2-3准备数据：1是否开启财务.答案值 等于 开启记账 or D2-3准备数据：1是否开启财务.答案值 等于 开启财务) and D2-3准备数据：3是否开启预算.答案值 等于 是)  60570

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
    if(omsTarget !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("BUDGET_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1520830_1_60573
queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:1520831_1_60573
if(omsTarget!=null){
      queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjId(omsTarget.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1520829_1_60573
    }

    /*D2-3准备数据：4预算设置层级[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：4预算设置层级-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：4预算设置层级-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：4预算设置层级-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_4 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto_4== null||  queryConfItemMatchAnswerDetailComRespDto_4.getEndValue() ==null,"找不到数据，系统异常",false);


           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_6 = null;
    if(omsTarget !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("BUDGET_REPORT_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1520834_1_60574
queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:1520835_1_60574
if(omsTarget!=null){
      queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjId(omsTarget.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1520833_1_60574
    }

    /*D2-3准备数据：5费用汇报层级[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：5费用汇报层级-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：5费用汇报层级-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：5费用汇报层级-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_6 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto_6== null||  queryConfItemMatchAnswerDetailComRespDto_6.getEndValue() ==null,"找不到数据，系统异常",false);


           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_8 = null;
    if(omsTarget !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_4=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_4.setConfItemCode("IS_OPEN_FUNDS_ARRIVAL");//CUSTOM_CONVENTION//sourceId:1520837_1_60575
queryConfItemMatchAnswerDetailComReqDto_4.setIsPlatData("FALSE");//sourceId:1520838_1_60575
if(omsTarget!=null){
      queryConfItemMatchAnswerDetailComReqDto_4.setResultAspObjId(omsTarget.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1520836_1_60575
    }

    /*D2-3准备数据：6是否开启到账[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：6是否开启到账-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：6是否开启到账-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：6是否开启到账-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_8 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_4).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto_8== null||  queryConfItemMatchAnswerDetailComRespDto_8.getEndValue() ==null,"找不到数据，系统异常",false);


           }
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_10 = null;
    if(omsTarget !=null){
          QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_5=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_5.setConfItemCode("CASH_ACCOUNT_UNIT");//CUSTOM_CONVENTION//sourceId:1520863_1_60580
queryConfItemMatchAnswerDetailComReqDto_5.setIsPlatData("FALSE");//sourceId:1520864_1_60580
if(omsTarget!=null){
      queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjId(omsTarget.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1520862_1_60580
    }

    /*D2-3准备数据：7资金单位[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getResultAspObjId(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：7资金单位-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getConfItemCode(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：7资金单位-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getIsPlatData(),"D3执行全内容统计资金来源及账户(公共)-D2-3准备数据：7资金单位-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_10 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_5).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryConfItemMatchAnswerDetailComRespDto_10== null||  queryConfItemMatchAnswerDetailComRespDto_10.getEndValue() ==null,"找不到数据，系统异常",false);


           }
//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
    // TODO: 2024/2/24
    receptionServiceReq.setDataObjectBatchCode("DB"+CommonFunctionHelper.getUid());//CUSTOM_CONVENTION//sourceId:1538064_1_61048

    /*M3准备数据：8数据对象批次标识[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getDataObjectBatchCode(),"D3执行全内容统计资金来源及账户(公共)-M3准备数据：8数据对象批次标识-数据对象批次标识不能为空",false);
      receptionServiceRes = nbFinance.implementFiveReceivingField(receptionServiceReq);



//ModelCode: receptionService
        ObtainReceiveOutFieldRespDto receptionServiceRes_2 = null;
    ObtainReceiveOutFieldReqDto receptionServiceReq_1=new ObtainReceiveOutFieldReqDto();
  receptionServiceReq_1.setCustomField1("ADD_BUDGET_ACCOUNT");//CUSTOM_CONVENTION//sourceId:1555419_1_61528
receptionServiceReq_1.setCustomField2("ADD_PHYSICAL_ACCOUNT");//CUSTOM_CONVENTION//sourceId:1555420_1_61528

    /*M3准备数据：约定增预算账户或实体账户[4608]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getCustomField1(),"D3执行全内容统计资金来源及账户(公共)-M3准备数据：约定增预算账户或实体账户-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq_1.getCustomField2(),"D3执行全内容统计资金来源及账户(公共)-M3准备数据：约定增预算账户或实体账户-自定义字段2不能为空",false);
      receptionServiceRes_2 = nbFinance.obtainReceiveOutField(receptionServiceReq_1);



OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1520235_1_60576
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1520228_1_60576
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1520240_1_60576
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getTargetId());//SimpleFieldAssign//sourceId:1520236_1_60576
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1520279_1_60576
    }

    /*3-3-09查目标的被评对象目标父周期详情[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行全内容统计资金来源及账户(公共)-3-3-09查目标的被评对象目标父周期详情-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行全内容统计资金来源及账户(公共)-3-3-09查目标的被评对象目标父周期详情-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行全内容统计资金来源及账户(公共)-3-3-09查目标的被评对象目标父周期详情-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-3-3-09查目标的被评对象目标父周期详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行全内容统计资金来源及账户(公共)-3-3-09查目标的被评对象目标父周期详情-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsEvaluationObjectTargetCycle== null||  omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode() ==null,"找不到数据，系统异常",false);


QueryWholeTreeTargetContentListComRespDto queryWholeTreeTargetContentListComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryWholeTreeTargetContentListComReqDto queryWholeTreeTargetContentListComReqDto=new QueryWholeTreeTargetContentListComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      queryWholeTreeTargetContentListComReqDto.setEvaObjTargetCycleCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1520200_1_60577
queryWholeTreeTargetContentListComReqDto.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1520193_1_60577
queryWholeTreeTargetContentListComReqDto.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1520195_1_60577
queryWholeTreeTargetContentListComReqDto.setEvaluationTemplateId(omsEvaluationObjectTargetCycle.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1520197_1_60577
queryWholeTreeTargetContentListComReqDto.setIsParentCycle(omsEvaluationObjectTargetCycle.getIsParentCycle());//SimpleFieldAssign//sourceId:1520199_1_60577
    }

    /*D3查询全树目标内容列表(公共)[5840]   */
    Assert.isNull(queryWholeTreeTargetContentListComReqDto.getEvaObjTargetCycleCode(),"D3执行全内容统计资金来源及账户(公共)-D3查询全树目标内容列表(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(queryWholeTreeTargetContentListComReqDto.getEvaObjEntityId(),"D3执行全内容统计资金来源及账户(公共)-D3查询全树目标内容列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryWholeTreeTargetContentListComReqDto.getEvaObjTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D3查询全树目标内容列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryWholeTreeTargetContentListComReqDto.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-D3查询全树目标内容列表(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(queryWholeTreeTargetContentListComReqDto.getIsParentCycle(),"D3执行全内容统计资金来源及账户(公共)-D3查询全树目标内容列表(公共)-是否父周期不能为空",false);
      queryWholeTreeTargetContentListComRespDto = targetContentService.queryWholeTreeTargetContentListCom(queryWholeTreeTargetContentListComReqDto)/*vcase invoke isSameApp*/;



           }
//ModelCode: circulationCollections
        for (EvaObjTargetCycleDto circulationCollectionsRes: queryWholeTreeTargetContentListComRespDto.getEvaObjTargetCycleList()){

ImplementAnalyzeInputsFinancialAccountsComRespDto implementAnalyzeInputsFinancialAccountsComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto_2 !=null&&queryConfItemMatchAnswerDetailComRespDto_4 !=null&&queryConfItemMatchAnswerDetailComRespDto_6 !=null&&queryConfItemMatchAnswerDetailComRespDto_8 !=null&&omsTarget !=null){
          ImplementAnalyzeInputsFinancialAccountsComReqDto implementAnalyzeInputsFinancialAccountsComReqDto=new ImplementAnalyzeInputsFinancialAccountsComReqDto();
  if(queryConfItemMatchAnswerDetailComRespDto_2!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setIsOpenBudget(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1537905_1_60793
    }
if(queryConfItemMatchAnswerDetailComRespDto_4!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setBudgetLevel(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1536739_1_60793
    }
if(queryConfItemMatchAnswerDetailComRespDto_6!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setCostReportLevel(queryConfItemMatchAnswerDetailComRespDto_6.getEndValue());//SimpleFieldAssign//sourceId:1536740_1_60793
    }
if(queryConfItemMatchAnswerDetailComRespDto_8!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setIsOpenFundsArrival(queryConfItemMatchAnswerDetailComRespDto_8.getEndValue());//SimpleFieldAssign//sourceId:1537931_1_60793
    }
if(omsTarget!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setPeriodicModeTypeCode(omsTarget.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1536741_1_60793
    }
if(circulationCollectionsRes!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setFatherEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1536742_1_60793
implementAnalyzeInputsFinancialAccountsComReqDto.setParentEvaObjTargetCycleId(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1536743_1_60793
implementAnalyzeInputsFinancialAccountsComReqDto.setCurrentContentCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1556708_1_60793
implementAnalyzeInputsFinancialAccountsComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1536744_1_60793
implementAnalyzeInputsFinancialAccountsComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1536745_1_60793
    }
if(reqDto!=null){
      implementAnalyzeInputsFinancialAccountsComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1536746_1_60793
    }

    /*D3执行分析财务账户关键入参(公共)[8413]   */
    Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getIsOpenBudget(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-是否开启预算不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getBudgetLevel(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-预算层级不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getPeriodicModeTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getFatherEvaObjTargetCycleId(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-父周期被评对象目标周期ID不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getParentEvaObjTargetCycleId(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getCurrentContentCode(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-当前内容标识不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getTargetCycleContentId(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getTargetCycleContentTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAnalyzeInputsFinancialAccountsComReqDto.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-D3执行分析财务账户关键入参(公共)-冗余评价模板ID不能为空",false);
      implementAnalyzeInputsFinancialAccountsComRespDto = implementAnalyzeInputsFinancialAccountsCom(implementAnalyzeInputsFinancialAccountsComReqDto)/*vcase invoke 同服务,同domain*/;



           }
if((implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getIsExecuteFinaceHandle() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getIsExecuteFinaceHandle().equals("TRUE"))) {
        //if(D3执行分析财务账户关键入参(公共).是否执行财务处理 等于 是)  60994

if((implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode().equals("ADD_BUDGET_ACCOUNT")||implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode().equals("ADD_BOTH"))) {
        //if((D3执行分析财务账户关键入参(公共).增财务账户类型编码 等于 增预算账户 or D3执行分析财务账户关键入参(公共).增财务账户类型编码 等于 增预算账户与实体账户))  60997

ImplementFinancialAccountPromotionRedisComRespDto implementFinancialAccountPromotionRedisComRespDto = null;
    if(implementAnalyzeInputsFinancialAccountsComRespDto !=null){
          ImplementFinancialAccountPromotionRedisComReqDto implementFinancialAccountPromotionRedisComReqDto=new ImplementFinancialAccountPromotionRedisComReqDto();
  implementFinancialAccountPromotionRedisComReqDto.setIsExecuteFinaceHandle("TRUE");//sourceId:1530715_1_60999
if(receptionServiceRes_2!=null){
      implementFinancialAccountPromotionRedisComReqDto.setCreateBudgetOrFundAccount(receptionServiceRes_2.getCustomField1());//SimpleFieldAssign//sourceId:1555104_1_60999
    }
if(receptionServiceRes!=null){
      implementFinancialAccountPromotionRedisComReqDto.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1530717_1_60999
    }
if(implementAnalyzeInputsFinancialAccountsComRespDto!=null){
implementFinancialAccountPromotionRedisComReqDto.setIsStatisticalAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalBudgetAccount());//SimpleFieldAssign//sourceId:1530718_1_60999
implementFinancialAccountPromotionRedisComReqDto.setIsIncomingAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1530719_1_60999
    }
if(circulationCollectionsRes!=null){
    implementFinancialAccountPromotionRedisComReqDto.setAccountObjectId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1530720_1_60999
implementFinancialAccountPromotionRedisComReqDto.setAccountObjectTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1530721_1_60999
implementFinancialAccountPromotionRedisComReqDto.setAccountContentCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1530722_1_60999
implementFinancialAccountPromotionRedisComReqDto.setParentAccountContentCode(circulationCollectionsRes.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1553979_1_60999
    }
if(reqDto!=null){
      implementFinancialAccountPromotionRedisComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1530723_1_60999
    }

    /*D7执行财务账户推redis(公共)[8456]   */
    Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getIsExecuteFinaceHandle(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-是否执行财务处理不能为空",false);
    Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getCreateBudgetOrFundAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-增预算或实体账户不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getDataObjectBatchCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-数据对象批次标识不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getIsStatisticalAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-是否统计账户不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getAccountObjectId(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getAccountObjectTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体类型编码不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getAccountContentCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体标识不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto.getThemeContentId(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-主题内容ID不能为空",false);
      implementFinancialAccountPromotionRedisComRespDto = fwFinanceFinanceClient.implementFinancialAccountPromotionRedisCom(implementFinancialAccountPromotionRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
if((implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode().equals("ADD_PHYSICAL_ACCOUNT")||implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode().equals("ADD_BOTH"))) {
        //if((D3执行分析财务账户关键入参(公共).增财务账户类型编码 等于 增实体账户 or D3执行分析财务账户关键入参(公共).增财务账户类型编码 等于 增预算账户与实体账户))  61054

AnalysisBudgetAccountContentCodeComRespDto analysisBudgetAccountContentCodeComRespDto = null;
    if(implementAnalyzeInputsFinancialAccountsComRespDto !=null&&queryConfItemMatchAnswerDetailComRespDto_4 !=null){
          AnalysisBudgetAccountContentCodeComReqDto analysisBudgetAccountContentCodeComReqDto=new AnalysisBudgetAccountContentCodeComReqDto();
  if(implementAnalyzeInputsFinancialAccountsComRespDto!=null){
      analysisBudgetAccountContentCodeComReqDto.setIsStatisticalEntityAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalEntityAccount());//SimpleFieldAssign//sourceId:1554896_1_61514
    }
if(queryConfItemMatchAnswerDetailComRespDto_4!=null){
      analysisBudgetAccountContentCodeComReqDto.setBudgetHierarchy(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1554894_1_61514
    }
if(circulationCollectionsRes!=null){
      analysisBudgetAccountContentCodeComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1554890_1_61514
analysisBudgetAccountContentCodeComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554891_1_61514
    }
if(reqDto!=null){
      analysisBudgetAccountContentCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554892_1_61514
    }

    /*D3-分析预算账户归属主体标识(公共)[8515]   */
    Assert.isNull(analysisBudgetAccountContentCodeComReqDto.getIsStatisticalEntityAccount(),"D3执行全内容统计资金来源及账户(公共)-D3-分析预算账户归属主体标识(公共)-是否统计实体账户不能为空",false);
Assert.isNull(analysisBudgetAccountContentCodeComReqDto.getBudgetHierarchy(),"D3执行全内容统计资金来源及账户(公共)-D3-分析预算账户归属主体标识(公共)-预算层级不能为空",false);
Assert.isNull(analysisBudgetAccountContentCodeComReqDto.getTargetCycleContentTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D3-分析预算账户归属主体标识(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(analysisBudgetAccountContentCodeComReqDto.getTargetCycleContentId(),"D3执行全内容统计资金来源及账户(公共)-D3-分析预算账户归属主体标识(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisBudgetAccountContentCodeComReqDto.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-D3-分析预算账户归属主体标识(公共)-冗余评价模板ID不能为空",false);
      analysisBudgetAccountContentCodeComRespDto = analysisBudgetAccountContentCodeCom(analysisBudgetAccountContentCodeComReqDto)/*vcase invoke 同服务,同domain*/;



           }
ImplementFinancialAccountPromotionRedisComRespDto implementFinancialAccountPromotionRedisComRespDto_1 = null;
    if(implementAnalyzeInputsFinancialAccountsComRespDto !=null&&analysisBudgetAccountContentCodeComRespDto !=null){
          ImplementFinancialAccountPromotionRedisComReqDto implementFinancialAccountPromotionRedisComReqDto_1=new ImplementFinancialAccountPromotionRedisComReqDto();
  implementFinancialAccountPromotionRedisComReqDto_1.setIsExecuteFinaceHandle("TRUE");//sourceId:1530715_1_61055
if(receptionServiceRes_2!=null){
      implementFinancialAccountPromotionRedisComReqDto_1.setCreateBudgetOrFundAccount(receptionServiceRes_2.getCustomField2());//SimpleFieldAssign//sourceId:1555104_1_61055
    }
if(receptionServiceRes!=null){
      implementFinancialAccountPromotionRedisComReqDto_1.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1530717_1_61055
    }
if(implementAnalyzeInputsFinancialAccountsComRespDto!=null){
implementFinancialAccountPromotionRedisComReqDto_1.setIsStatisticalAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalEntityAccount());//SimpleFieldAssign//sourceId:1530718_1_61055
implementFinancialAccountPromotionRedisComReqDto_1.setIsIncomingAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1530719_1_61055
    }
if(circulationCollectionsRes!=null){
    implementFinancialAccountPromotionRedisComReqDto_1.setAccountObjectId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1530720_1_61055
implementFinancialAccountPromotionRedisComReqDto_1.setAccountObjectTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1530721_1_61055
implementFinancialAccountPromotionRedisComReqDto_1.setAccountContentCode(circulationCollectionsRes.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1530722_1_61055
implementFinancialAccountPromotionRedisComReqDto_1.setParentAccountContentCode(circulationCollectionsRes.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1553979_1_61055
    }
if(analysisBudgetAccountContentCodeComRespDto!=null){
      implementFinancialAccountPromotionRedisComReqDto_1.setRelSubBudgetAccountCode(analysisBudgetAccountContentCodeComRespDto.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1553982_1_61055
    }
if(reqDto!=null){
      implementFinancialAccountPromotionRedisComReqDto_1.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1530723_1_61055
    }

    /*D7执行财务账户推redis(公共)[8456]   */
    Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getIsExecuteFinaceHandle(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-是否执行财务处理不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getCreateBudgetOrFundAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-增预算或实体账户不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getDataObjectBatchCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-数据对象批次标识不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getIsStatisticalAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-是否统计账户不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getAccountObjectId(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getAccountObjectTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体类型编码不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getAccountContentCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-关联归属主体标识不能为空",false);
Assert.isNull(implementFinancialAccountPromotionRedisComReqDto_1.getThemeContentId(),"D3执行全内容统计资金来源及账户(公共)-D7执行财务账户推redis(公共)-主题内容ID不能为空",false);
      implementFinancialAccountPromotionRedisComRespDto_1 = fwFinanceFinanceClient.implementFinancialAccountPromotionRedisCom(implementFinancialAccountPromotionRedisComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



           }
    }
if((implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalBudgetAccount() !=null && implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalBudgetAccount().equals("TRUE")&&implementAnalyzeInputsFinancialAccountsComRespDto!= null&& implementAnalyzeInputsFinancialAccountsComRespDto.getIsLastStaticBudgetAccount() != null )) {
        //if((D3执行分析财务账户关键入参(公共).是否统计预算账户 等于 是 and D3执行分析财务账户关键入参(公共).是否末级统计预算账户 值不等于空 ))  61662

ImplementSingleContentCountTargetFundingSourceBudgetSetRedisComRespDto implementSingleContentCountTargetFundingSourceBudgetSetRedisComRespDto = null;
    if(omsTarget !=null&&implementAnalyzeInputsFinancialAccountsComRespDto !=null){
          ImplementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto=new ImplementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto();
  implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setIsExecuteFinaceHandle("TRUE");//sourceId:1529069_1_61663
if(reqDto!=null){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1529071_1_61663
    }
if(omsTarget!=null){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setPeriodicModeTypeCode(omsTarget.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1529064_1_61663
    }
if(implementAnalyzeInputsFinancialAccountsComRespDto!=null){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setAddFinAccountTypeCode(implementAnalyzeInputsFinancialAccountsComRespDto.getAddFinAccountTypeCode());//SimpleFieldAssign//sourceId:1556566_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setIsStatisticalAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsStatisticalBudgetAccount());//SimpleFieldAssign//sourceId:1529068_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setIsLastStaticAccount(implementAnalyzeInputsFinancialAccountsComRespDto.getIsLastStaticBudgetAccount());//SimpleFieldAssign//sourceId:1529070_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setFatherEvaObjTargetCycleId(implementAnalyzeInputsFinancialAccountsComRespDto.getFatherEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1529065_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setParentCycleList(implementAnalyzeInputsFinancialAccountsComRespDto.getParentCycleList());//list-field-assign//sourceId:1529063_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setMidTermList(implementAnalyzeInputsFinancialAccountsComRespDto.getMidTermList());//list-field-assign//sourceId:1529062_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setMidEvaObjTargetCycleId(implementAnalyzeInputsFinancialAccountsComRespDto.getMidEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1529066_1_61663
    }
if(receptionServiceRes!=null){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1529074_1_61663
    }
if(circulationCollectionsRes!=null){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setTargetCycleContentId(circulationCollectionsRes.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1529072_1_61663
implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setTargetCycleContentTypeCode(circulationCollectionsRes.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1529073_1_61663
    }
if(implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getSuperiorEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(implementAnalyzeInputsFinancialAccountsComRespDto.getSuperiorEvaObjTargetCycleList())){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setSuperiorEvaObjTargetCycleList(implementAnalyzeInputsFinancialAccountsComRespDto.getSuperiorEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrfinance.integration.dto.SuperiorEvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1529060_1_61663
    }
if(implementAnalyzeInputsFinancialAccountsComRespDto!= null&&  implementAnalyzeInputsFinancialAccountsComRespDto.getSubCycleList() !=null&& !CollectionUtil.isEmpty(implementAnalyzeInputsFinancialAccountsComRespDto.getSubCycleList())){
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.setSubCycleList(implementAnalyzeInputsFinancialAccountsComRespDto.getSubCycleList().stream().map(item -> BeanUtil.toBean(item, com.wicket.okrfinance.integration.dto.SubCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1529061_1_61663
    }

    /*D7执行单内容统计目标资金来源预算推redis(公共)[8415]   */
    Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-评价模板ID不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getPeriodicModeTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getIsExecuteFinaceHandle(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-是否执行财务处理不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getAddFinAccountTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-增财务账户类型编码不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getIsStatisticalAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-是否统计账户不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getIsLastStaticAccount(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-是否末级统计账户不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getDataObjectBatchCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-数据对象批次标识不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getTargetCycleContentId(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getTargetCycleContentTypeCode(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto.getFatherEvaObjTargetCycleId(),"D3执行全内容统计资金来源及账户(公共)-D7执行单内容统计目标资金来源预算推redis(公共)-父周期被评对象目标周期ID不能为空",false);
      implementSingleContentCountTargetFundingSourceBudgetSetRedisComRespDto = fwFinanceFinanceClient.implementSingleContentCountTargetFundingSourceBudgetSetRedisCom(implementSingleContentCountTargetFundingSourceBudgetSetRedisComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
           }
      }
//ModelCode: circulationEnd
        }

ImplementInitializeTargetFinAndBudgetSetComRespDto implementInitializeTargetFinAndBudgetSetComRespDto = null;
    if(queryConfItemMatchAnswerDetailComRespDto_10 !=null){
          ImplementInitializeTargetFinAndBudgetSetComReqDto implementInitializeTargetFinAndBudgetSetComReqDto=new ImplementInitializeTargetFinAndBudgetSetComReqDto();
  implementInitializeTargetFinAndBudgetSetComReqDto.setIsOrgOfficialAccountNom("FALSE");//sourceId:1538074_1_61461
if(receptionServiceRes!=null){
      implementInitializeTargetFinAndBudgetSetComReqDto.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1538071_1_61461
    }
if(queryConfItemMatchAnswerDetailComRespDto_10!=null){
      implementInitializeTargetFinAndBudgetSetComReqDto.setCycleBudgetUnit(queryConfItemMatchAnswerDetailComRespDto_10.getConfOptionName());//SimpleFieldAssign//sourceId:1538072_1_61461
    }
if(reqDto!=null){
      implementInitializeTargetFinAndBudgetSetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1538073_1_61461
    }

    /*D7-执行初始化目标财务账户及预算设置(公共)[8463]   */
    Assert.isNull(implementInitializeTargetFinAndBudgetSetComReqDto.getDataObjectBatchCode(),"D3执行全内容统计资金来源及账户(公共)-D7-执行初始化目标财务账户及预算设置(公共)-数据对象批次标识不能为空",false);
Assert.isNull(implementInitializeTargetFinAndBudgetSetComReqDto.getCycleBudgetUnit(),"D3执行全内容统计资金来源及账户(公共)-D7-执行初始化目标财务账户及预算设置(公共)-冗余预算单位不能为空",false);
Assert.isNull(implementInitializeTargetFinAndBudgetSetComReqDto.getIsOrgOfficialAccountNom(),"D3执行全内容统计资金来源及账户(公共)-D7-执行初始化目标财务账户及预算设置(公共)-是否组织正式财务标准不能为空",false);
Assert.isNull(implementInitializeTargetFinAndBudgetSetComReqDto.getEvaluationTemplateId(),"D3执行全内容统计资金来源及账户(公共)-D7-执行初始化目标财务账户及预算设置(公共)-评价模板ID不能为空",false);
      implementInitializeTargetFinAndBudgetSetComRespDto = fwFinanceFinanceClient.implementInitializeTargetFinAndBudgetSetCom(implementInitializeTargetFinAndBudgetSetComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto = null;
    DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto=new DeleteRedisBusinessDataComReqDto();
  deleteRedisBusinessDataComReqDto.setRedisDataObjectCatalogue("计算临时数据");//sourceId:1834737_1_61664
  deleteRedisBusinessDataComReqDto.setBusinessDataObject("INIT_BUDGET_AND_REAL_ACCT");//sourceId:1558532_1_61664
deleteRedisBusinessDataComReqDto.setIsDataList("TRUE");//sourceId:1558535_1_61664
if(receptionServiceRes!=null){
      deleteRedisBusinessDataComReqDto.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1558534_1_61664
    }

    /*D2-删除初始化预算或实体账户redis[8397]   */
    Assert.isNull(deleteRedisBusinessDataComReqDto.getRedisDataObjectCatalogue(),"D3执行全内容统计资金来源及账户(公共)-D2-删除初始化预算或实体账户redis-Redis数据对象目录不能为空",false);
    Assert.isNull(deleteRedisBusinessDataComReqDto.getBusinessDataObject(),"D3执行全内容统计资金来源及账户(公共)-D2-删除初始化预算或实体账户redis-业务数据对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataComReqDto.getIsDataList(),"D3执行全内容统计资金来源及账户(公共)-D2-删除初始化预算或实体账户redis-是否是数据集对象不能为空",false);
      deleteRedisBusinessDataComRespDto = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



DeleteRedisBusinessDataComRespDto deleteRedisBusinessDataComRespDto_1 = null;
    DeleteRedisBusinessDataComReqDto deleteRedisBusinessDataComReqDto_1=new DeleteRedisBusinessDataComReqDto();
  deleteRedisBusinessDataComReqDto_1.setRedisDataObjectCatalogue("计算临时数据");//sourceId:1834738_1_61665
  deleteRedisBusinessDataComReqDto_1.setBusinessDataObject("TARGET_BUDGET_SET");//sourceId:1558536_1_61665
deleteRedisBusinessDataComReqDto_1.setIsDataList("TRUE");//sourceId:1558539_1_61665
if(receptionServiceRes!=null){
      deleteRedisBusinessDataComReqDto_1.setDataObjectBatchCode(receptionServiceRes.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1558538_1_61665
    }

    /*D2-删除目标预算设置redis[8397]   */
    Assert.isNull(deleteRedisBusinessDataComReqDto_1.getRedisDataObjectCatalogue(),"D3执行全内容统计资金来源及账户(公共)-D2-删除目标预算设置redis-Redis数据对象目录不能为空",false);
    Assert.isNull(deleteRedisBusinessDataComReqDto_1.getBusinessDataObject(),"D3执行全内容统计资金来源及账户(公共)-D2-删除目标预算设置redis-业务数据对象不能为空",false);
Assert.isNull(deleteRedisBusinessDataComReqDto_1.getIsDataList(),"D3执行全内容统计资金来源及账户(公共)-D2-删除目标预算设置redis-是否是数据集对象不能为空",false);
      deleteRedisBusinessDataComRespDto_1 = fwCompInterfaceModeClient.deleteRedisBusinessDataCom(deleteRedisBusinessDataComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;



      }
ImplementAllContentCountFundingSourcesAccountsComRespDto retData = new ImplementAllContentCountFundingSourcesAccountsComRespDto();





return retData;
  }
/**
   * D3执行准备财务入参信息(公共)[8472]
   * gen by moon at 7/3/2024, 6:24:25 PM
   */
  @Trace(operationName = "D3执行准备财务入参信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementPreCurTargetContFinDataComRespDto implementPreCurTargetContFinDataCom(ImplementPreCurTargetContFinDataComReqDto reqDto){


      ImplementIsOrgOfficialAccountNomAnalyzeComRespDto implementIsOrgOfficialAccountNomAnalyzeComRespDto_1 =null;
ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1 =null;
      QuerySpaceDetailComRespDto querySpaceDetailComRespDto_1 =null;
if((reqDto!= null&&  reqDto.getIsLastCycle() !=null && reqDto.getIsLastCycle().equals("TRUE")&&reqDto!= null&& reqDto.getAccountId() != null &&reqDto!= null&& reqDto.getBudgetDisburse() != null &&reqDto!= null&&  reqDto.getIsStatisticalAccount() !=null && reqDto.getIsStatisticalAccount().equals("FALSE"))) {
        //if((D3执行准备财务入参信息(公共).是否末级周期 等于 是 and D3执行准备财务入参信息(公共).账户ID 值不等于空  and D3执行准备财务入参信息(公共).预算支出金额 值不等于空  and D3执行准备财务入参信息(公共).是否统计账户 等于 否))  62242

ImplementIsOrgOfficialAccountNomAnalyzeComRespDto implementIsOrgOfficialAccountNomAnalyzeComRespDto = null;
    ImplementIsOrgOfficialAccountNomAnalyzeComReqDto implementIsOrgOfficialAccountNomAnalyzeComReqDto=new ImplementIsOrgOfficialAccountNomAnalyzeComReqDto();
if(reqDto!=null){
      implementIsOrgOfficialAccountNomAnalyzeComReqDto.setEndValue(reqDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1571160_1_62243
    }

    /*D7执行是否组织正式财务标准分析(公共)[8047]   */
    Assert.isNull(implementIsOrgOfficialAccountNomAnalyzeComReqDto.getEndValue(),"D3执行准备财务入参信息(公共)-D7执行是否组织正式财务标准分析(公共)-空间开启财务模式答案不能为空",false);
      implementIsOrgOfficialAccountNomAnalyzeComRespDto = fwFinanceFinanceClient.implementIsOrgOfficialAccountNomAnalyzeCom(implementIsOrgOfficialAccountNomAnalyzeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementIsOrgOfficialAccountNomAnalyzeComRespDto_1 = implementIsOrgOfficialAccountNomAnalyzeComRespDto;
      ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto implementGenerateBillBusinessStoriesAndAccountInfoComRespDto = null;
    ImplementGenerateBillBusinessStoriesAndAccountInfoComReqDto implementGenerateBillBusinessStoriesAndAccountInfoComReqDto=new ImplementGenerateBillBusinessStoriesAndAccountInfoComReqDto();
  if(reqDto!=null){
      implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563188_1_62244
implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1563158_1_62244
implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563157_1_62244
    }

    /*D3执行生成账单业务故事及科目信息(公共)[8538]   */
    Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getEvaObjTargetCycleId(),"D3执行准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getUpdateCycleId(),"D3执行准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-更新周期ID不能为空",false);
Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getEvaluationTemplateId(),"D3执行准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-冗余评价模板ID不能为空",false);
      implementGenerateBillBusinessStoriesAndAccountInfoComRespDto = implementGenerateBillBusinessStoriesAndAccountInfoCom(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto)/*vcase invoke 同服务,同domain*/;


      implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1 = implementGenerateBillBusinessStoriesAndAccountInfoComRespDto;
      QuerySpaceDetailComRespDto querySpaceDetailComRespDto = null;
    QuerySpaceDetailComReqDto querySpaceDetailComReqDto=new QuerySpaceDetailComReqDto();
  querySpaceDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1533307_1_62245

    /*D1查空间LOGO及简称（公共）[402]   */
    Assert.isNull(querySpaceDetailComReqDto.getSpaceId(),"D3执行准备财务入参信息(公共)-D1查空间LOGO及简称（公共）-空间ID不能为空",false);
      querySpaceDetailComRespDto = fwBaseBaseClient.querySpaceDetailCom(querySpaceDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      querySpaceDetailComRespDto_1 = querySpaceDetailComRespDto;
      }
else if((reqDto!= null&&  reqDto.getIsLastCycle() !=null && reqDto.getIsLastCycle().equals("TRUE")&&reqDto!= null&&  reqDto.getIsStatisticalAccount() !=null && reqDto.getIsStatisticalAccount().equals("TRUE")&&reqDto!= null&& reqDto.getBudgetDisburse() != null )){
       //elseif((D3执行准备财务入参信息(公共).是否末级周期 等于 是 and D3执行准备财务入参信息(公共).是否统计账户 等于 是 and D3执行准备财务入参信息(公共).预算支出金额 值不等于空 ))  71222

//异常结束 71224
      throw new BizException("CC10000478","对不起，财务预算汇报数据异常~",false);
    }
ImplementPreCurTargetContFinDataComRespDto retData = new ImplementPreCurTargetContFinDataComRespDto();
  if(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1!=null){
      retData.setBudgetAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetAccountId());//SimpleFieldAssign//sourceId:1569496_1
retData.setEntityAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getEntityAccountId());//SimpleFieldAssign//sourceId:1569497_1
retData.setRelSubBudgetAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getRelSubBudgetAccountId());//SimpleFieldAssign//sourceId:1785997_1
retData.setRelSubBudgetAccountCode(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1569499_1
retData.setIsIncomingAccount(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1569498_1
retData.setBillAmount(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBillAmount());//SimpleFieldAssign//sourceId:1567931_1
retData.setFundUsageSubjectld(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getFundUsageSubjectld());//SimpleFieldAssign//sourceId:1567992_1
retData.setBudgetExpenditureAsld(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetExpenditureAsld());//SimpleFieldAssign//sourceId:1567920_1
retData.setBudgetExpensesReceivedAsId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetExpensesReceivedAsId());//SimpleFieldAssign//sourceId:1567921_1
retData.setStoryBillBusiness(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getStoryBillBusiness());//SimpleFieldAssign//sourceId:1567923_1
retData.setOperationInductionId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1568832_1
    }
if(implementIsOrgOfficialAccountNomAnalyzeComRespDto_1!=null){
      retData.setIsOrgOfficialAccountNom(implementIsOrgOfficialAccountNomAnalyzeComRespDto_1.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1571165_1
    }
  if(querySpaceDetailComRespDto_1!=null){
      retData.setSpaceLogo(querySpaceDetailComRespDto_1.getSpaceLogo());//SimpleFieldAssign//sourceId:1563427_1
retData.setAbbreviation(querySpaceDetailComRespDto_1.getAbbreviation());//SimpleFieldAssign//sourceId:1563428_1
    }




return retData;
  }
/**
   * D3执行分析财务账户关键入参(公共)[8413]
   * gen by moon at 5/28/2024, 11:41:48 AM
   */
  @Trace(operationName = "D3执行分析财务账户关键入参(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementAnalyzeInputsFinancialAccountsComRespDto implementAnalyzeInputsFinancialAccountsCom(ImplementAnalyzeInputsFinancialAccountsComReqDto reqDto){


ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto_1 =null;
ImplementAnalysisAddFinAccountTypeCodeComRespDto implementAnalysisAddFinAccountTypeCodeComRespDto_1 =null;
ImplementBudgetSetPreparationTargetDataComRespDto implementBudgetSetPreparationTargetDataComRespDto_1 =null;
//virtualUsage D3分析目标内容业务层级(公共)  61547
      AnalysisTargetContentBusinessHierarchyComRespDto analysisTargetContentBusinessHierarchyComRespDto = null;
    AnalysisTargetContentBusinessHierarchyComReqDto analysisTargetContentBusinessHierarchyComReqDto=new AnalysisTargetContentBusinessHierarchyComReqDto();
  if(reqDto!=null){
      analysisTargetContentBusinessHierarchyComReqDto.setIsOpenBudget(reqDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1556865_1_61547
analysisTargetContentBusinessHierarchyComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1556574_1_61547
analysisTargetContentBusinessHierarchyComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1556575_1_61547
analysisTargetContentBusinessHierarchyComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1556576_1_61547
    }

    /*D3分析目标内容业务层级(公共)[8462]   */
    Assert.isNull(analysisTargetContentBusinessHierarchyComReqDto.getIsOpenBudget(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容业务层级(公共)-是否开启预算不能为空",false);
Assert.isNull(analysisTargetContentBusinessHierarchyComReqDto.getTargetCycleContentTypeCode(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容业务层级(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(analysisTargetContentBusinessHierarchyComReqDto.getTargetCycleContentId(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容业务层级(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisTargetContentBusinessHierarchyComReqDto.getEvaluationTemplateId(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容业务层级(公共)-冗余评价模板ID不能为空",false);
      analysisTargetContentBusinessHierarchyComRespDto = indexSystemService.analysisTargetContentBusinessHierarchyCom(analysisTargetContentBusinessHierarchyComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3分析目标内容是否开启预算(公共)  61030
      AnalysisTargetContentIsOpenBudgetComRespDto analysisTargetContentIsOpenBudgetComRespDto = null;
    if(analysisTargetContentBusinessHierarchyComRespDto !=null){
    AnalysisTargetContentIsOpenBudgetComReqDto analysisTargetContentIsOpenBudgetComReqDto=new AnalysisTargetContentIsOpenBudgetComReqDto();
  if(reqDto!=null){
      analysisTargetContentIsOpenBudgetComReqDto.setIsOpenBudget(reqDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1556998_1_61030
analysisTargetContentIsOpenBudgetComReqDto.setBudgetLevel(reqDto.getBudgetLevel());//SimpleFieldAssign//sourceId:1556758_1_61030
analysisTargetContentIsOpenBudgetComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1556887_1_61030
analysisTargetContentIsOpenBudgetComReqDto.setCurrentContentCode(reqDto.getCurrentContentCode());//SimpleFieldAssign//sourceId:1556679_1_61030
analysisTargetContentIsOpenBudgetComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1537893_1_61030
    }
if(analysisTargetContentBusinessHierarchyComRespDto!=null){
      analysisTargetContentIsOpenBudgetComReqDto.setTargetBusinessLevel(analysisTargetContentBusinessHierarchyComRespDto.getTargetBusinessLevel());//SimpleFieldAssign//sourceId:1556759_1_61030
    }

    /*D3分析目标内容是否开启预算(公共)[8483]   */
    Assert.isNull(analysisTargetContentIsOpenBudgetComReqDto.getIsOpenBudget(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容是否开启预算(公共)-是否开启预算不能为空",false);
Assert.isNull(analysisTargetContentIsOpenBudgetComReqDto.getTargetCycleContentId(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容是否开启预算(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisTargetContentIsOpenBudgetComReqDto.getCurrentContentCode(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容是否开启预算(公共)-当前内容标识不能为空",false);
Assert.isNull(analysisTargetContentIsOpenBudgetComReqDto.getEvaluationTemplateId(),"D3执行分析财务账户关键入参(公共)-D3分析目标内容是否开启预算(公共)-冗余评价模板ID不能为空",false);
      analysisTargetContentIsOpenBudgetComRespDto = indexSystemService.analysisTargetContentIsOpenBudgetCom(analysisTargetContentIsOpenBudgetComReqDto)/*vcase invoke isSameApp*/;



           }
if((analysisTargetContentIsOpenBudgetComRespDto!= null&&  analysisTargetContentIsOpenBudgetComRespDto.getIsSetBudgetUpAndDown() !=null && analysisTargetContentIsOpenBudgetComRespDto.getIsSetBudgetUpAndDown().equals("TRUE"))) {
        //if(D3分析当前及上下层级目标内容是否开启预算(公共).上下文是否有预算设置 等于 是)  61031

ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1537481_1_61032
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTargetCycleContentTypeCode(),"D3执行分析财务账户关键入参(公共)-D3执行内容类型互转表类型(公共)-关联目标内容类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;


      implementContentTypeChangeTableTypeComRespDto_1 = implementContentTypeChangeTableTypeComRespDto;
ImplementAnalysisAddFinAccountTypeCodeComRespDto implementAnalysisAddFinAccountTypeCodeComRespDto = null;
    if(analysisTargetContentBusinessHierarchyComRespDto !=null){
    ImplementAnalysisAddFinAccountTypeCodeComReqDto implementAnalysisAddFinAccountTypeCodeComReqDto=new ImplementAnalysisAddFinAccountTypeCodeComReqDto();
  if(analysisTargetContentBusinessHierarchyComRespDto!=null){
      implementAnalysisAddFinAccountTypeCodeComReqDto.setCateOrObjLevel(analysisTargetContentBusinessHierarchyComRespDto.getCateOrObjLevel());//SimpleFieldAssign//sourceId:1559861_1_61033
      implementAnalysisAddFinAccountTypeCodeComReqDto.setTargetBusinessLevel(analysisTargetContentBusinessHierarchyComRespDto.getTargetBusinessLevel());//SimpleFieldAssign//sourceId:1556573_1_61033
    }
  if(reqDto!=null){
      implementAnalysisAddFinAccountTypeCodeComReqDto.setBudgetLevel(reqDto.getBudgetLevel());//SimpleFieldAssign//sourceId:1534044_1_61033
implementAnalysisAddFinAccountTypeCodeComReqDto.setCostReportLevel(reqDto.getCostReportLevel());//SimpleFieldAssign//sourceId:1534045_1_61033
implementAnalysisAddFinAccountTypeCodeComReqDto.setIsOpenFundsArrival(reqDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1537928_1_61033
implementAnalysisAddFinAccountTypeCodeComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1534046_1_61033
implementAnalysisAddFinAccountTypeCodeComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1534047_1_61033
implementAnalysisAddFinAccountTypeCodeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1534048_1_61033
    }

    /*D3执行分析增财务账户类型编码(公共)[8470]   */
    Assert.isNull(implementAnalysisAddFinAccountTypeCodeComReqDto.getTargetBusinessLevel(),"D3执行分析财务账户关键入参(公共)-D3执行分析增财务账户类型编码(公共)-目标内容业务层级不能为空",false);
    Assert.isNull(implementAnalysisAddFinAccountTypeCodeComReqDto.getBudgetLevel(),"D3执行分析财务账户关键入参(公共)-D3执行分析增财务账户类型编码(公共)-预算层级不能为空",false);
Assert.isNull(implementAnalysisAddFinAccountTypeCodeComReqDto.getTargetCycleContentTypeCode(),"D3执行分析财务账户关键入参(公共)-D3执行分析增财务账户类型编码(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementAnalysisAddFinAccountTypeCodeComReqDto.getTargetCycleContentId(),"D3执行分析财务账户关键入参(公共)-D3执行分析增财务账户类型编码(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementAnalysisAddFinAccountTypeCodeComReqDto.getEvaluationTemplateId(),"D3执行分析财务账户关键入参(公共)-D3执行分析增财务账户类型编码(公共)-冗余评价模板ID不能为空",false);
      implementAnalysisAddFinAccountTypeCodeComRespDto = indexSystemService.implementAnalysisAddFinAccountTypeCodeCom(implementAnalysisAddFinAccountTypeCodeComReqDto)/*vcase invoke isSameApp*/;


      implementAnalysisAddFinAccountTypeCodeComRespDto_1 = implementAnalysisAddFinAccountTypeCodeComRespDto;
           }
if((implementAnalysisAddFinAccountTypeCodeComRespDto!= null&&  implementAnalysisAddFinAccountTypeCodeComRespDto.getIsExecuteFinaceHandle() !=null && implementAnalysisAddFinAccountTypeCodeComRespDto.getIsExecuteFinaceHandle().equals("TRUE"))) {
        //if(D3执行分析增预算与实体财务账户(公共).是否执行财务处理 等于 是)  61034

ImplementBudgetSetPreparationTargetDataComRespDto implementBudgetSetPreparationTargetDataComRespDto = null;
    ImplementBudgetSetPreparationTargetDataComReqDto implementBudgetSetPreparationTargetDataComReqDto=new ImplementBudgetSetPreparationTargetDataComReqDto();
  if(reqDto!=null){
      implementBudgetSetPreparationTargetDataComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1536606_1_61035
implementBudgetSetPreparationTargetDataComReqDto.setFatherEvaObjTargetCycleId(reqDto.getFatherEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1536609_1_61035
implementBudgetSetPreparationTargetDataComReqDto.setParentEvaObjTargetCycleId(reqDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1536610_1_61035
implementBudgetSetPreparationTargetDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1536607_1_61035
implementBudgetSetPreparationTargetDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1536608_1_61035
    }

    /*D3执行预算设置准备目标内容数据(公共)[8465]   */
    Assert.isNull(implementBudgetSetPreparationTargetDataComReqDto.getPeriodicModeTypeCode(),"D3执行分析财务账户关键入参(公共)-D3执行预算设置准备目标内容数据(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementBudgetSetPreparationTargetDataComReqDto.getFatherEvaObjTargetCycleId(),"D3执行分析财务账户关键入参(公共)-D3执行预算设置准备目标内容数据(公共)-父周期被评对象目标周期ID不能为空",false);
Assert.isNull(implementBudgetSetPreparationTargetDataComReqDto.getParentEvaObjTargetCycleId(),"D3执行分析财务账户关键入参(公共)-D3执行预算设置准备目标内容数据(公共)-上级被评对象目标周期标识不能为空",false);
Assert.isNull(implementBudgetSetPreparationTargetDataComReqDto.getTargetCycleContentId(),"D3执行分析财务账户关键入参(公共)-D3执行预算设置准备目标内容数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementBudgetSetPreparationTargetDataComReqDto.getEvaluationTemplateId(),"D3执行分析财务账户关键入参(公共)-D3执行预算设置准备目标内容数据(公共)-冗余评价模板ID不能为空",false);
      implementBudgetSetPreparationTargetDataComRespDto = indexSystemService.implementBudgetSetPreparationTargetDataCom(implementBudgetSetPreparationTargetDataComReqDto)/*vcase invoke isSameApp*/;


      implementBudgetSetPreparationTargetDataComRespDto_1 = implementBudgetSetPreparationTargetDataComRespDto;
      }
      }
ImplementAnalyzeInputsFinancialAccountsComRespDto retData = new ImplementAnalyzeInputsFinancialAccountsComRespDto();
  if(implementAnalysisAddFinAccountTypeCodeComRespDto_1!=null){
      retData.setIsExecuteFinaceHandle(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsExecuteFinaceHandle());//SimpleFieldAssign//sourceId:1536716_1
retData.setAddFinAccountTypeCode(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getAddFinAccountTypeCode());//SimpleFieldAssign//sourceId:1536717_1
retData.setIsLastStaticBudgetAccount(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsLastStaticBudgetAccount());//SimpleFieldAssign//sourceId:1536718_1
retData.setIsStatisticalBudgetAccount(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsStatisticalBudgetAccount());//SimpleFieldAssign//sourceId:1536719_1
retData.setIsLastStaticEntityAccount(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsLastStaticEntityAccount());//SimpleFieldAssign//sourceId:1536720_1
retData.setIsStatisticalEntityAccount(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsStatisticalEntityAccount()!=null?String.valueOf(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsStatisticalEntityAccount()):"");//SimpleFieldAssign//sourceId:1536721_1
retData.setIsIncomingAccount(implementAnalysisAddFinAccountTypeCodeComRespDto_1.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1538006_1
    }
if(implementContentTypeChangeTableTypeComRespDto_1!=null){
      retData.setTableTypeCode(implementContentTypeChangeTableTypeComRespDto_1.getTableTypeCode());//SimpleFieldAssign//sourceId:1537487_1
    }
if(implementBudgetSetPreparationTargetDataComRespDto_1!=null){
      retData.setSuperiorEvaObjTargetCycleList(implementBudgetSetPreparationTargetDataComRespDto_1.getSuperiorEvaObjTargetCycleList().stream().map(item -> BeanUtil.toBean(item, SuperiorEvaObjTargetCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1536728_1
retData.setSubCycleList(implementBudgetSetPreparationTargetDataComRespDto_1.getSubCycleList().stream().map(item -> BeanUtil.toBean(item, SubCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1536725_1
retData.setFatherEvaObjTargetCycleId(implementBudgetSetPreparationTargetDataComRespDto_1.getFatherEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1536723_1
retData.setParentCycleList(implementBudgetSetPreparationTargetDataComRespDto_1.getParentCycleList());//list-field-assign//sourceId:1536727_1
retData.setMidEvaObjTargetCycleId(implementBudgetSetPreparationTargetDataComRespDto_1.getMidEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1536722_1
retData.setMidTermList(implementBudgetSetPreparationTargetDataComRespDto_1.getMidTermList());//list-field-assign//sourceId:1536724_1
    }




return retData;
  }
/**
   * D3-分析预算账户归属主体标识(公共)[8515]
   * gen by moon at 2/19/2024, 2:49:37 PM
   */
  @Trace(operationName = "D3-分析预算账户归属主体标识(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisBudgetAccountContentCodeComRespDto analysisBudgetAccountContentCodeCom(AnalysisBudgetAccountContentCodeComReqDto reqDto){


      ImplementFourthReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getIsStatisticalEntityAccount() !=null && reqDto.getIsStatisticalEntityAccount().equals("FALSE"))) {
        //if(D3-分析预算账户归属主体标识(公共).是否统计实体账户 等于 否)  61464

if((reqDto!= null&&  reqDto.getBudgetHierarchy() !=null && reqDto.getBudgetHierarchy().equals("PLAN_BUDGET"))) {
        //if(D3-分析预算账户归属主体标识(公共).预算层级 等于 预算在规划)  61472

OmsTarget omsTarget = null;
    QueryTargetDetailReq queryTargetDetailReq=new QueryTargetDetailReq();
  queryTargetDetailReq.setIsArchive("FALSE");//sourceId:1555097_1_61525
if(reqDto!=null){
      queryTargetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1555096_1_61525
    }

    /*3-3-01查目标详情[2488]   */
    Assert.isNull(queryTargetDetailReq.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-01查目标详情-归属评价模板ID不能为空",false);
Assert.isNull(queryTargetDetailReq.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-01查目标详情-是否存档不能为空",false);
      omsTarget = mOmsTargetService.queryTargetDetail(queryTargetDetailReq)/*vcase invoke 本地 method 方法调用;*/;
      Assert.isTrue(omsTarget== null||  omsTarget.getTargetCode() ==null,"找不到数据，系统异常",false);


//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes = null;
    if(omsTarget !=null){
    ImplementFourthReceivingFieldReqDto receptionServiceReq=new ImplementFourthReceivingFieldReqDto();
  if(omsTarget!=null){
      receptionServiceReq.setRelSubBudgetAccountCode(omsTarget.getTargetCode());//SimpleFieldAssign//sourceId:1554495_1_61474
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes = nbFinance.implementFourthReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
    }
      }
else if((reqDto!= null&&  reqDto.getBudgetHierarchy() !=null && reqDto.getBudgetHierarchy().equals("PRIMARY_CON_TASK_BUDGET"))){
       //elseif(D3-分析预算账户归属主体标识(公共).预算层级 等于 一级建设任务)  61475

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
        //if(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 目标分类)  61478

OmsTargetCategory omsTargetCategory = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq.setIsArchive("FALSE");//sourceId:1554874_1_61480
if(reqDto!=null){
      queryTargetCatDetailReq.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554872_1_61480
queryTargetCatDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554873_1_61480
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq.getTargetCategoryId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategory!= null&& omsTargetCategory.getLevelNumber() == 1L)) {
        //if(3-3-02查入参目标分类详情（获取目标分类层级、标识）.层级 等于 1)  61481

//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetCategory !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_1=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetCategory!=null){
      receptionServiceReq_1.setRelSubBudgetAccountCode(omsTargetCategory.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1554495_1_61483
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_2 = nbFinance.implementFourthReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
      }
else if((omsTargetCategory!= null&& omsTargetCategory.getLevelNumber() > 1L)){
       //elseif(3-3-02查入参目标分类详情（获取目标分类层级、标识）.层级 大于 1)  61482

OmsTargetCategory omsTargetCategory_2 = null;
    if(omsTargetCategory !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_1=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_1.setIsArchive("FALSE");//sourceId:1554874_1_61484
if(omsTargetCategory!=null){
      queryTargetCatDetailReq_1.setTargetCategoryId(omsTargetCategory.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1554872_1_61484
    }
if(reqDto!=null){
      queryTargetCatDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554873_1_61484
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_1.getTargetCategoryId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_1.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_1.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_2 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_3 = null;
    if(omsTargetCategory_2 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_2=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetCategory_2!=null){
      receptionServiceReq_2.setRelSubBudgetAccountCode(omsTargetCategory_2.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1554495_1_61485
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_3 = nbFinance.implementFourthReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 指标)  61479

OmsTargetObjective omsTargetObjective = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq.setIsArchive("FALSE");//sourceId:1554881_1_61486
if(reqDto!=null){
      queryTargetObjDetailReq.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554879_1_61486
queryTargetObjDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554880_1_61486
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq.getObjectiveId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCategory omsTargetCategory_3 = null;
    if(omsTargetObjective !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_2=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_2.setIsArchive("FALSE");//sourceId:1554874_1_61487
if(omsTargetObjective!=null){
      queryTargetCatDetailReq_2.setTargetCategoryId(omsTargetObjective.getRootTargetCategoryId());//SimpleFieldAssign//sourceId:1554872_1_61487
    }
if(reqDto!=null){
      queryTargetCatDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554873_1_61487
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_2.getTargetCategoryId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_2.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_2.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_3 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_4 = null;
    if(omsTargetCategory_3 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_3=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetCategory_3!=null){
      receptionServiceReq_3.setRelSubBudgetAccountCode(omsTargetCategory_3.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1554495_1_61488
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_4 = nbFinance.implementFourthReceivingField(receptionServiceReq_3);


      receptionServiceRes_1 = receptionServiceRes_4;
           }
    }
    }
else if((reqDto!= null&&  reqDto.getBudgetHierarchy() !=null && reqDto.getBudgetHierarchy().equals("LAST_CON_TASK_BUDGET"))){
       //elseif(D3-分析预算账户归属主体标识(公共).预算层级 等于 末级建设任务)  61489

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("TARGET_CATEGORY"))) {
        //if(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 目标分类)  61491

OmsTargetCategory omsTargetCategory_4 = null;
    QueryTargetCatDetailReq queryTargetCatDetailReq_3=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_3.setIsArchive("FALSE");//sourceId:1554874_1_61493
if(reqDto!=null){
      queryTargetCatDetailReq_3.setTargetCategoryId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554872_1_61493
queryTargetCatDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554873_1_61493
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_3.getTargetCategoryId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_3.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_3.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_4 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetCategory_4!= null&&  omsTargetCategory_4.getIsLast() !=null && omsTargetCategory_4.getIsLast().equals("TRUE"))) {
        //if(3-3-02查入参目标分类详情（是否末级目标分类）.目标分类是否末级 等于 是)  61494

//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_5 = null;
    if(omsTargetCategory_4 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_4=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetCategory_4!=null){
      receptionServiceReq_4.setRelSubBudgetAccountCode(omsTargetCategory_4.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1554495_1_61495
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_5 = nbFinance.implementFourthReceivingField(receptionServiceReq_4);


      receptionServiceRes_1 = receptionServiceRes_5;
           }
      }
else{
       //else  61517

//异常结束 61518
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
      }
else if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))){
       //elseif(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 指标)  61492

OmsTargetObjective omsTargetObjective_2 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_1=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_1.setIsArchive("FALSE");//sourceId:1554881_1_61496
if(reqDto!=null){
      queryTargetObjDetailReq_1.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554879_1_61496
queryTargetObjDetailReq_1.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554880_1_61496
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_1.getObjectiveId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_1.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_1.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_2 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_1)/*vcase invoke 本地 method 方法调用;*/;



OmsTargetCategory omsTargetCategory_5 = null;
    if(omsTargetObjective_2 !=null){
          QueryTargetCatDetailReq queryTargetCatDetailReq_4=new QueryTargetCatDetailReq();
  queryTargetCatDetailReq_4.setIsArchive("FALSE");//sourceId:1554874_1_61497
if(omsTargetObjective_2!=null){
      queryTargetCatDetailReq_4.setTargetCategoryId(omsTargetObjective_2.getCorrelationLastTargetCatId());//SimpleFieldAssign//sourceId:1554872_1_61497
    }
if(reqDto!=null){
      queryTargetCatDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554873_1_61497
    }

    /*3-3-02查目标分类详情[2595]   */
    Assert.isNull(queryTargetCatDetailReq_4.getTargetCategoryId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-目标分类ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_4.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatDetailReq_4.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-02查目标分类详情-是否存档不能为空",false);
      omsTargetCategory_5 = mOmsTargetCategoryService.queryTargetCatDetail(queryTargetCatDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_6 = null;
    if(omsTargetCategory_5 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_5=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetCategory_5!=null){
      receptionServiceReq_5.setRelSubBudgetAccountCode(omsTargetCategory_5.getTargetCategoryCode());//SimpleFieldAssign//sourceId:1554495_1_61498
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_6 = nbFinance.implementFourthReceivingField(receptionServiceReq_5);


      receptionServiceRes_1 = receptionServiceRes_6;
           }
    }
    }
else if((reqDto!= null&&  reqDto.getBudgetHierarchy() !=null && reqDto.getBudgetHierarchy().equals("ONE_LEVEL_OBSERVATION_POINT_BUDGET"))){
       //elseif(D3-分析预算账户归属主体标识(公共).预算层级 等于 一级观测点预算)  61499

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 指标)  61501

OmsTargetObjective omsTargetObjective_3 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_2=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_2.setIsArchive("FALSE");//sourceId:1554881_1_61502
if(reqDto!=null){
      queryTargetObjDetailReq_2.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554879_1_61502
queryTargetObjDetailReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554880_1_61502
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_2.getObjectiveId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_2.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_2.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_3 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_2)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjective_3!= null&& omsTargetObjective_3.getLevelNumber() == 1L)) {
        //if(3-3-03查入参指标详情（获取指标层级、标识）.层级 等于 1)  61503

//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_7 = null;
    if(omsTargetObjective_3 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_6=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetObjective_3!=null){
      receptionServiceReq_6.setRelSubBudgetAccountCode(omsTargetObjective_3.getObjectiveCode());//SimpleFieldAssign//sourceId:1554495_1_61505
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_6.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_7 = nbFinance.implementFourthReceivingField(receptionServiceReq_6);


      receptionServiceRes_1 = receptionServiceRes_7;
           }
      }
else if((omsTargetObjective_3!= null&& omsTargetObjective_3.getLevelNumber() > 1L)){
       //elseif(3-3-03查入参指标详情（获取指标层级、标识）.层级 大于 1)  61504

OmsTargetObjective omsTargetObjective_4 = null;
    if(omsTargetObjective_3 !=null){
          QueryTargetObjDetailReq queryTargetObjDetailReq_3=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_3.setIsArchive("FALSE");//sourceId:1554881_1_61506
if(omsTargetObjective_3!=null){
      queryTargetObjDetailReq_3.setObjectiveId(omsTargetObjective_3.getRootObjectiveId());//SimpleFieldAssign//sourceId:1554879_1_61506
    }
if(reqDto!=null){
      queryTargetObjDetailReq_3.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554880_1_61506
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_3.getObjectiveId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_3.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_3.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_4 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_3)/*vcase invoke 本地 method 方法调用;*/;



           }
//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_8 = null;
    if(omsTargetObjective_4 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_7=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetObjective_4!=null){
      receptionServiceReq_7.setRelSubBudgetAccountCode(omsTargetObjective_4.getObjectiveCode());//SimpleFieldAssign//sourceId:1554495_1_61507
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_7.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_8 = nbFinance.implementFourthReceivingField(receptionServiceReq_7);


      receptionServiceRes_1 = receptionServiceRes_8;
           }
    }
      }
else{
       //else  61519

//异常结束 61520
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
    }
else if((reqDto!= null&&  reqDto.getBudgetHierarchy() !=null && reqDto.getBudgetHierarchy().equals("LAST_LEVEL_OBSERVATION_POINT_BUDGET"))){
       //elseif(D3-分析预算账户归属主体标识(公共).预算层级 等于 末级观测点预算)  61508

if((reqDto!= null&&  reqDto.getTargetCycleContentTypeCode() !=null && reqDto.getTargetCycleContentTypeCode().equals("OBJECTIVE"))) {
        //if(D3-分析预算账户归属主体标识(公共).关联目标内容类型编码 等于 指标)  61510

OmsTargetObjective omsTargetObjective_5 = null;
    QueryTargetObjDetailReq queryTargetObjDetailReq_4=new QueryTargetObjDetailReq();
  queryTargetObjDetailReq_4.setIsArchive("FALSE");//sourceId:1554881_1_61511
if(reqDto!=null){
      queryTargetObjDetailReq_4.setObjectiveId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1554879_1_61511
queryTargetObjDetailReq_4.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1554880_1_61511
    }

    /*3-3-03查指标详情[2697]   */
    Assert.isNull(queryTargetObjDetailReq_4.getObjectiveId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-指标ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_4.getEvaluationTemplateId(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjDetailReq_4.getIsArchive(),"D3-分析预算账户归属主体标识(公共)-3-3-03查指标详情-是否存档不能为空",false);
      omsTargetObjective_5 = mOmsTargetObjectiveService.queryTargetObjDetail(queryTargetObjDetailReq_4)/*vcase invoke 本地 method 方法调用;*/;



if((omsTargetObjective_5!= null&&  omsTargetObjective_5.getIsLastObjective() !=null && omsTargetObjective_5.getIsLastObjective().equals("TRUE"))) {
        //if(3-3-03查指标详情（是否末级指标）.是否末级指标 等于 是)  61512

//ModelCode: receptionService
        ImplementFourthReceivingFieldRespDto receptionServiceRes_9 = null;
    if(omsTargetObjective_5 !=null){
          ImplementFourthReceivingFieldReqDto receptionServiceReq_8=new ImplementFourthReceivingFieldReqDto();
  if(omsTargetObjective_5!=null){
      receptionServiceReq_8.setRelSubBudgetAccountCode(omsTargetObjective_5.getObjectiveCode());//SimpleFieldAssign//sourceId:1554495_1_61513
    }

    /*约定出参：关联扣减预算账户归属主体标识[8259]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_8.getRelSubBudgetAccountCode(),"D3-分析预算账户归属主体标识(公共)-约定出参：关联扣减预算账户归属主体标识-关联扣减预算账户归属主体标识不能为空",false);
      receptionServiceRes_9 = nbFinance.implementFourthReceivingField(receptionServiceReq_8);


      receptionServiceRes_1 = receptionServiceRes_9;
           }
      }
else{
       //else  61523

//异常结束 61524
      throw new BizException("500","系统异常，请联系管理员！",false);
           }
      }
else{
       //else  61521

//异常结束 61522
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
    }
else{
       //else  61515

//异常结束 61516
      throw new BizException("500","系统异常，请联系管理员！",false);
    }
      }
AnalysisBudgetAccountContentCodeComRespDto retData = new AnalysisBudgetAccountContentCodeComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setRelSubBudgetAccountCode(receptionServiceRes_1.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1554889_1
    }




return retData;
  }
/**
   * D3执行开启或关闭目标预算[8519]
   * gen by moon at 2/27/2024, 10:44:33 PM
   */
  @Trace(operationName = "D3执行开启或关闭目标预算")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementOpenOrCloseTargetBudgetRespDto implementOpenOrCloseTargetBudget(ImplementOpenOrCloseTargetBudgetReqDto reqDto){


      //virtualUsage D3执行目标内容预算启用状态修改(公共)  61538
      ImplementTargetContBudgetEnableUpdateComRespDto implementTargetContBudgetEnableUpdateComRespDto = null;
    ImplementTargetContBudgetEnableUpdateComReqDto implementTargetContBudgetEnableUpdateComReqDto=new ImplementTargetContBudgetEnableUpdateComReqDto();
  if(reqDto!=null){
      implementTargetContBudgetEnableUpdateComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1556118_1_61538
implementTargetContBudgetEnableUpdateComReqDto.setEntityId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1556119_1_61538
implementTargetContBudgetEnableUpdateComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1556120_1_61538
implementTargetContBudgetEnableUpdateComReqDto.setIsUseBudget(reqDto.getIsUseBudget());//SimpleFieldAssign//sourceId:1556121_1_61538
    }

    /*D3执行目标内容预算启用状态修改(公共)[7984]   */
    Assert.isNull(implementTargetContBudgetEnableUpdateComReqDto.getTableTypeCode(),"D3执行开启或关闭目标预算-D3执行目标内容预算启用状态修改(公共)-内容表类型编码不能为空",false);
Assert.isNull(implementTargetContBudgetEnableUpdateComReqDto.getEntityId(),"D3执行开启或关闭目标预算-D3执行目标内容预算启用状态修改(公共)-内容表主键ID不能为空",false);
Assert.isNull(implementTargetContBudgetEnableUpdateComReqDto.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-D3执行目标内容预算启用状态修改(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(implementTargetContBudgetEnableUpdateComReqDto.getIsUseBudget(),"D3执行开启或关闭目标预算-D3执行目标内容预算启用状态修改(公共)-是否开启预算不能为空",false);
      implementTargetContBudgetEnableUpdateComRespDto = targetContentService.implementTargetContBudgetEnableUpdateCom(implementTargetContBudgetEnableUpdateComReqDto)/*vcase invoke isSameApp*/;



if((reqDto!= null&&  reqDto.getIsUseBudget() !=null && reqDto.getIsUseBudget().equals("FALSE")&&implementTargetContBudgetEnableUpdateComRespDto!= null&&  implementTargetContBudgetEnableUpdateComRespDto.getIsUseBudget() !=null && implementTargetContBudgetEnableUpdateComRespDto.getIsUseBudget().equals("TRUE")&&implementTargetContBudgetEnableUpdateComRespDto!= null&&  implementTargetContBudgetEnableUpdateComRespDto.getSubjectLifeCycle() !=null && implementTargetContBudgetEnableUpdateComRespDto.getSubjectLifeCycle().equals("EDITING"))) {
        //if((D3执行开启或关闭目标预算.是否开启预算 等于 否 and D3执行目标内容预算启用状态修改(公共).是否开启预算 等于 是 and D3执行目标内容预算启用状态修改(公共).主体生命周期 等于 正在编辑))  61539

OmsEvaluationObjectTargetCycle omsEvaluationObjectTargetCycle = null;
    QueryEvaObjTargetCycleDetailReq queryEvaObjTargetCycleDetailReq=new QueryEvaObjTargetCycleDetailReq();
  queryEvaObjTargetCycleDetailReq.setEvaObjEntityId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1556530_1_61544
queryEvaObjTargetCycleDetailReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1556531_1_61544
queryEvaObjTargetCycleDetailReq.setIsParentCycle("TRUE");//sourceId:1556533_1_61544
queryEvaObjTargetCycleDetailReq.setIsArchive("FALSE");//sourceId:1556535_1_61544
if(reqDto!=null){
      queryEvaObjTargetCycleDetailReq.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1556532_1_61544
queryEvaObjTargetCycleDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1556534_1_61544
    }

    /*3-3-09查当前内容目标父周期（用于清理预算入参）[2313]   */
    Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjEntityId(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaObjTypeCode(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getTargetCycleContentId(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsParentCycle(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-是否父周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleDetailReq.getIsArchive(),"D3执行开启或关闭目标预算-3-3-09查当前内容目标父周期（用于清理预算入参）-是否存档不能为空",false);
      omsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleDetail(queryEvaObjTargetCycleDetailReq)/*vcase invoke 本地 method 方法调用;*/;



QueryAncestorTargetCycleListComRespDto queryAncestorTargetCycleListComRespDto = null;
    if(omsEvaluationObjectTargetCycle !=null){
          QueryAncestorTargetCycleListComReqDto queryAncestorTargetCycleListComReqDto=new QueryAncestorTargetCycleListComReqDto();
  if(omsEvaluationObjectTargetCycle!=null){
      queryAncestorTargetCycleListComReqDto.setComCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1556538_1_61546
queryAncestorTargetCycleListComReqDto.setEvaObjEntityId(omsEvaluationObjectTargetCycle.getEvaObjEntityId());//SimpleFieldAssign//sourceId:1556539_1_61546
queryAncestorTargetCycleListComReqDto.setEvaObjTypeCode(omsEvaluationObjectTargetCycle.getEvaObjTypeCode());//SimpleFieldAssign//sourceId:1556540_1_61546
    }
if(reqDto!=null){
      queryAncestorTargetCycleListComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1556541_1_61546
    }

    /*D3查祖先目标周期列表(公共)[6312]   */
    Assert.isNull(queryAncestorTargetCycleListComReqDto.getComCode(),"D3执行开启或关闭目标预算-D3查祖先目标周期列表(公共)-通用编码标识不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjEntityId(),"D3执行开启或关闭目标预算-D3查祖先目标周期列表(公共)-被评对象内容表主键ID不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaObjTypeCode(),"D3执行开启或关闭目标预算-D3查祖先目标周期列表(公共)-被评对象类型编码不能为空",false);
Assert.isNull(queryAncestorTargetCycleListComReqDto.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-D3查祖先目标周期列表(公共)-冗余评价模板ID不能为空",false);
      queryAncestorTargetCycleListComRespDto = targetContentService.queryAncestorTargetCycleListCom(queryAncestorTargetCycleListComReqDto)/*vcase invoke isSameApp*/;



           }
ImplementClearTargetBudgetAndBillAccountComRespDto implementClearTargetBudgetAndBillAccountComRespDto = null;
    if(queryAncestorTargetCycleListComRespDto !=null&&omsEvaluationObjectTargetCycle !=null){
          ImplementClearTargetBudgetAndBillAccountComReqDto implementClearTargetBudgetAndBillAccountComReqDto=new ImplementClearTargetBudgetAndBillAccountComReqDto();
  if(queryAncestorTargetCycleListComRespDto!= null&&  queryAncestorTargetCycleListComRespDto.getEvaObjTargetCycleList() !=null&& !CollectionUtil.isEmpty(queryAncestorTargetCycleListComRespDto.getEvaObjTargetCycleList())){
      implementClearTargetBudgetAndBillAccountComReqDto.setFinanceAccountList(//objList-to-objLists
        queryAncestorTargetCycleListComRespDto.getEvaObjTargetCycleList().stream().map(item -> {
            com.wicket.okrfinance.integration.dto.FinanceAccountDto elm = new com.wicket.okrfinance.integration.dto.FinanceAccountDto();
      if(item!=null){
      elm.setAccountObjectId(item.getTargetCycleContentId());//SimpleFieldAssign//sourceId:304746_2_61543
elm.setParentAccountContentCode(item.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:304747_2_61543
    }
        return elm;
      }).collect(Collectors.toList()));//objList-to-objLists//sourceId:1556117_1_61543
    }
if(omsEvaluationObjectTargetCycle!=null){
      implementClearTargetBudgetAndBillAccountComReqDto.setAccountObjectId(omsEvaluationObjectTargetCycle.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1556114_1_61543
implementClearTargetBudgetAndBillAccountComReqDto.setAccountContentCode(omsEvaluationObjectTargetCycle.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1556115_1_61543
    }
if(reqDto!=null){
      implementClearTargetBudgetAndBillAccountComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1556116_1_61543
    }

    /*D7执行清理目标预算及账户账单(公共)[8508]   */
    Assert.isNull(implementClearTargetBudgetAndBillAccountComReqDto.getAccountObjectId(),"D3执行开启或关闭目标预算-D7执行清理目标预算及账户账单(公共)-关联归属主体ID不能为空",false);
Assert.isNull(implementClearTargetBudgetAndBillAccountComReqDto.getAccountContentCode(),"D3执行开启或关闭目标预算-D7执行清理目标预算及账户账单(公共)-关联归属主体标识不能为空",false);
Assert.isNull(implementClearTargetBudgetAndBillAccountComReqDto.getThemeContentId(),"D3执行开启或关闭目标预算-D7执行清理目标预算及账户账单(公共)-主题内容ID不能为空",false);
      implementClearTargetBudgetAndBillAccountComRespDto = fwFinanceFinanceClient.implementClearTargetBudgetAndBillAccountCom(implementClearTargetBudgetAndBillAccountComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
else if((reqDto!= null&&  reqDto.getIsUseBudget() !=null && reqDto.getIsUseBudget().equals("TRUE")&&implementTargetContBudgetEnableUpdateComRespDto!= null&&  implementTargetContBudgetEnableUpdateComRespDto.getIsUseBudget() !=null && implementTargetContBudgetEnableUpdateComRespDto.getIsUseBudget().equals("FALSE"))){
       //elseif((D3执行开启或关闭目标预算.是否开启预算 等于 是 and D3执行目标内容预算启用状态修改(公共).是否开启预算 等于 否))  61824

ImplementInitializeBudgetSetConfDataPrepareComRespDto implementInitializeBudgetSetConfDataPrepareComRespDto = null;
    ImplementInitializeBudgetSetConfDataPrepareComReqDto implementInitializeBudgetSetConfDataPrepareComReqDto=new ImplementInitializeBudgetSetConfDataPrepareComReqDto();
  if(reqDto!=null){
      implementInitializeBudgetSetConfDataPrepareComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1560798_1_61825
    }

    /*D3执行初始化预算设置配置数据准备(公共)[8449]   */
    Assert.isNull(implementInitializeBudgetSetConfDataPrepareComReqDto.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-D3执行初始化预算设置配置数据准备(公共)-冗余评价模板ID不能为空",false);
      implementInitializeBudgetSetConfDataPrepareComRespDto = targetContentService.implementInitializeBudgetSetConfDataPrepareCom(implementInitializeBudgetSetConfDataPrepareComReqDto)/*vcase invoke isSameApp*/;



ObtainTargetContentParentMetaphaseSubCycleComRespDto obtainTargetContentParentMetaphaseSubCycleComRespDto = null;
    ObtainTargetContentParentMetaphaseSubCycleComReqDto obtainTargetContentParentMetaphaseSubCycleComReqDto=new ObtainTargetContentParentMetaphaseSubCycleComReqDto();
  if(reqDto!=null){
      obtainTargetContentParentMetaphaseSubCycleComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1560801_1_61827
obtainTargetContentParentMetaphaseSubCycleComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1560802_1_61827
obtainTargetContentParentMetaphaseSubCycleComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1560803_1_61827
    }

    /*D3获取目标内容父子中周期(公共)[8446]   */
    Assert.isNull(obtainTargetContentParentMetaphaseSubCycleComReqDto.getTargetCycleContentId(),"D3执行开启或关闭目标预算-D3获取目标内容父子中周期(公共)-关联目标内容ID不能为空",false);
Assert.isNull(obtainTargetContentParentMetaphaseSubCycleComReqDto.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-D3获取目标内容父子中周期(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(obtainTargetContentParentMetaphaseSubCycleComReqDto.getPeriodicModeTypeCode(),"D3执行开启或关闭目标预算-D3获取目标内容父子中周期(公共)-周期模式类型编码不能为空",false);
      obtainTargetContentParentMetaphaseSubCycleComRespDto = targetContentService.obtainTargetContentParentMetaphaseSubCycleCom(obtainTargetContentParentMetaphaseSubCycleComReqDto)/*vcase invoke isSameApp*/;



ImplementContentTypeChangeTableTypeComRespDto implementContentTypeChangeTableTypeComRespDto = null;
    ImplementContentTypeChangeTableTypeComReqDto implementContentTypeChangeTableTypeComReqDto=new ImplementContentTypeChangeTableTypeComReqDto();
  if(reqDto!=null){
      implementContentTypeChangeTableTypeComReqDto.setTableTypeCode(reqDto.getTableTypeCode());//SimpleFieldAssign//sourceId:1560829_1_61832
    }

    /*D3执行内容类型互转表类型(公共)[5354]   */
    Assert.isNull(implementContentTypeChangeTableTypeComReqDto.getTableTypeCode(),"D3执行开启或关闭目标预算-D3执行内容类型互转表类型(公共)-内容表类型编码不能为空",false);
      implementContentTypeChangeTableTypeComRespDto = indexSystemService.implementContentTypeChangeTableTypeCom(implementContentTypeChangeTableTypeComReqDto)/*vcase invoke isSameApp*/;



ImplementInitializeTargetContentBudgetAccountSetEtcComRespDto implementInitializeTargetContentBudgetAccountSetEtcComRespDto = null;
    if(obtainTargetContentParentMetaphaseSubCycleComRespDto !=null&&implementContentTypeChangeTableTypeComRespDto !=null&&implementInitializeBudgetSetConfDataPrepareComRespDto !=null){
          ImplementInitializeTargetContentBudgetAccountSetEtcComReqDto implementInitializeTargetContentBudgetAccountSetEtcComReqDto=new ImplementInitializeTargetContentBudgetAccountSetEtcComReqDto();
  if(obtainTargetContentParentMetaphaseSubCycleComRespDto!=null){
      implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setSubCycleList(obtainTargetContentParentMetaphaseSubCycleComRespDto.getSubCycleList());//list-field-assign//sourceId:1560810_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setEvaObjTargetCycleId(obtainTargetContentParentMetaphaseSubCycleComRespDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1560811_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setMidEvaObjTargetCycleId(obtainTargetContentParentMetaphaseSubCycleComRespDto.getMidEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1560812_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setEvaObjTargetCycleCode(obtainTargetContentParentMetaphaseSubCycleComRespDto.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1560813_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setParentEvaObjTargetCycleId(obtainTargetContentParentMetaphaseSubCycleComRespDto.getParentEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1560822_1_61828
    }
if(reqDto!=null){
      implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setTargetCycleContentId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1560814_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1560816_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1560817_1_61828
    }
if(implementContentTypeChangeTableTypeComRespDto!=null){
      implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setTargetCycleContentTypeCode(implementContentTypeChangeTableTypeComRespDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1560815_1_61828
    }
if(implementInitializeBudgetSetConfDataPrepareComRespDto!=null){
      implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setCycleBudgetUnit(implementInitializeBudgetSetConfDataPrepareComRespDto.getBudgetUnit());//SimpleFieldAssign//sourceId:1560818_1_61828
implementInitializeTargetContentBudgetAccountSetEtcComReqDto.setIsOrgOfficialAccountNom(implementInitializeBudgetSetConfDataPrepareComRespDto.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1560819_1_61828
    }

    /*D7执行初始化目标内容预算账户及周期预算设置(公共)[8444]   */
    Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getEvaObjTargetCycleId(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getEvaObjTargetCycleCode(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-被评对象目标周期标识不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getTargetCycleContentId(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getTargetCycleContentTypeCode(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getEvaluationTemplateId(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-评价模板ID不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getPeriodicModeTypeCode(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-周期模式类型编码不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getCycleBudgetUnit(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-冗余预算单位不能为空",false);
Assert.isNull(implementInitializeTargetContentBudgetAccountSetEtcComReqDto.getIsOrgOfficialAccountNom(),"D3执行开启或关闭目标预算-D7执行初始化目标内容预算账户及周期预算设置(公共)-是否组织正式财务标准不能为空",false);
      implementInitializeTargetContentBudgetAccountSetEtcComRespDto = fwFinanceFinanceClient.implementInitializeTargetContentBudgetAccountSetEtcCom(implementInitializeTargetContentBudgetAccountSetEtcComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
      }
ImplementOpenOrCloseTargetBudgetRespDto retData = new ImplementOpenOrCloseTargetBudgetRespDto();





return retData;
  }
/**
   * D3查询目标内容预算子周期列表(公共)[8525]
   * gen by moon at 2/25/2024, 12:05:31 AM
   */
  @Trace(operationName = "D3查询目标内容预算子周期列表(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContentBudgetSubCycleListComRespDto queryTargetContentBudgetSubCycleListCom(QueryTargetContentBudgetSubCycleListComReqDto reqDto){


      List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle_1 =new ArrayList<>();
//步骤0: 3-3-09查被评对象目标周期列表（根据周期时间范围） - queryEvaObjTargetCycleList
     List<OmsEvaluationObjectTargetCycle> listOmsEvaluationObjectTargetCycle =new ArrayList<>();
    QueryEvaObjTargetCycleListReq queryEvaObjTargetCycleListReq=new QueryEvaObjTargetCycleListReq();
  queryEvaObjTargetCycleListReq.setEvaObjTypeCode("EVA_OBJECT");//sourceId:1558575_1
queryEvaObjTargetCycleListReq.setIsSubCycle("TRUE");//sourceId:1558577_1
queryEvaObjTargetCycleListReq.setIsArchive("FALSE");//sourceId:1558579_1
if(reqDto!=null){
      queryEvaObjTargetCycleListReq.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1558576_1
queryEvaObjTargetCycleListReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558578_1
    }

    /*3-3-09查被评对象目标周期列表（根据周期时间范围）[2190]   */
    Assert.isNull(queryEvaObjTargetCycleListReq.getTargetCycleContentId(),"D3查询目标内容预算子周期列表(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-关联目标内容ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaluationTemplateId(),"D3查询目标内容预算子周期列表(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-冗余评价模板ID不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getEvaObjTypeCode(),"D3查询目标内容预算子周期列表(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-被评对象类型编码不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsSubCycle(),"D3查询目标内容预算子周期列表(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否子周期不能为空",false);
Assert.isNull(queryEvaObjTargetCycleListReq.getIsArchive(),"D3查询目标内容预算子周期列表(公共)-3-3-09查被评对象目标周期列表（根据周期时间范围）-是否存档不能为空",false);
      listOmsEvaluationObjectTargetCycle = mOmsEvaluationObjectTargetCycleService.queryEvaObjTargetCycleList(queryEvaObjTargetCycleListReq)/*vcase invoke 本地 method 方法调用;*/;


      listOmsEvaluationObjectTargetCycle_1 = listOmsEvaluationObjectTargetCycle;

QueryTargetContentBudgetSubCycleListComRespDto retData = new QueryTargetContentBudgetSubCycleListComRespDto();
  retData.setSubCycleList(listOmsEvaluationObjectTargetCycle_1.stream().map(item -> BeanUtil.toBean(item, SubCycleDto.class)).collect(Collectors.toList()));//objList-to-objLists//sourceId:1558583_1




return retData;
  }
/**
   * D3查询目标内容预算设置状态详情[2859]
   * gen by moon at 2/25/2024, 11:27:58 AM
   */
  @Trace(operationName = "D3查询目标内容预算设置状态详情")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContentBudgetStateDetailRespDto queryTargetContentBudgetStateDetail(QueryTargetContentBudgetStateDetailReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if(D3查询目标内容预算设置状态详情.内容表类型编码 等于 指标表)  61666

OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
    QueryTargetObjPlanExDetailReq queryTargetObjPlanExDetailReq=new QueryTargetObjPlanExDetailReq();
  queryTargetObjPlanExDetailReq.setIsArchive("FALSE");//sourceId:1558732_1_61667
if(reqDto!=null){
      queryTargetObjPlanExDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:90886_1_61667
queryTargetObjPlanExDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558731_1_61667
    }

    /*3-3-05查指标扩展规划设置详情[2725]   */
    Assert.isNull(queryTargetObjPlanExDetailReq.getObjectiveId(),"D3查询目标内容预算设置状态详情-3-3-05查指标扩展规划设置详情-归属指标ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情-3-3-05查指标扩展规划设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情-3-3-05查指标扩展规划设置详情-是否存档不能为空",false);
      omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExDetail(queryTargetObjPlanExDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    if(omsTargetObjectivePlanExtend !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(omsTargetObjectivePlanExtend!=null){
      receptionServiceReq.setIsOpenBudget(omsTargetObjectivePlanExtend.getIsUseBudget());//SimpleFieldAssign//sourceId:1558734_1_61668
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getIsOpenBudget(),"D3查询目标内容预算设置状态详情-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes = nbFinance.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))){
       //elseif(D3查询目标内容预算设置状态详情.内容表类型编码 等于 目标分类表)  61669

OmsTargetCategoryExtend omsTargetCategoryExtend = null;
    QueryTargetCatExSetDetailReq queryTargetCatExSetDetailReq=new QueryTargetCatExSetDetailReq();
  queryTargetCatExSetDetailReq.setIsArchive("FALSE");//sourceId:1558786_1_61670
queryTargetCatExSetDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1558787_1_61670
if(reqDto!=null){
      queryTargetCatExSetDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1558784_1_61670
queryTargetCatExSetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558785_1_61670
    }

    /*3-3-02-01查询目标分类扩展设置详情[3294]   */
    Assert.isNull(queryTargetCatExSetDetailReq.getTargetCategoryId(),"D3查询目标内容预算设置状态详情-3-3-02-01查询目标分类扩展设置详情-归属目标分类ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情-3-3-02-01查询目标分类扩展设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情-3-3-02-01查询目标分类扩展设置详情-是否存档不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getSpaceId(),"D3查询目标内容预算设置状态详情-3-3-02-01查询目标分类扩展设置详情-创建于空间ID不能为空",false);
      omsTargetCategoryExtend = mOmsTargetCategoryExtendService.queryTargetCatExSetDetail(queryTargetCatExSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetCategoryExtend !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(omsTargetCategoryExtend!=null){
      receptionServiceReq_1.setIsOpenBudget(omsTargetCategoryExtend.getIsUseBudget());//SimpleFieldAssign//sourceId:1558734_1_61671
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsOpenBudget(),"D3查询目标内容预算设置状态详情-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes_2 = nbFinance.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET"))){
       //elseif(D3查询目标内容预算设置状态详情.内容表类型编码 等于 目标表)  61672

OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1558789_1_61673
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558788_1_61673
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
    if(omsEvaluationTemplate !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_2=new ImplementFiveReceivingFieldReqDto();
  if(omsEvaluationTemplate!=null){
      receptionServiceReq_2.setIsOpenBudget(omsEvaluationTemplate.getIsOpenBudget());//SimpleFieldAssign//sourceId:1558734_1_61674
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getIsOpenBudget(),"D3查询目标内容预算设置状态详情-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes_3 = nbFinance.implementFiveReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
QueryTargetContentBudgetStateDetailRespDto retData = new QueryTargetContentBudgetStateDetailRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsOpenBudget(receptionServiceRes_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1558791_1
    }




return retData;
  }
/**
   * D3查询目标内容预算设置状态详情(公共)[2859]
   * gen by moon at 2/27/2024, 10:44:17 PM
   */
  @Trace(operationName = "D3查询目标内容预算设置状态详情(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public QueryTargetContentBudgetStateDetailComRespDto queryTargetContentBudgetStateDetailCom(QueryTargetContentBudgetStateDetailComReqDto reqDto){


      ImplementFiveReceivingFieldRespDto receptionServiceRes_1 =null;
if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_OBJECTIVE"))) {
        //if(D3查询目标内容预算设置状态详情.内容表类型编码 等于 指标表)  61666

OmsTargetObjectivePlanExtend omsTargetObjectivePlanExtend = null;
    QueryTargetObjPlanExDetailReq queryTargetObjPlanExDetailReq=new QueryTargetObjPlanExDetailReq();
  queryTargetObjPlanExDetailReq.setIsArchive("FALSE");//sourceId:1558732_1_61667
if(reqDto!=null){
      queryTargetObjPlanExDetailReq.setObjectiveId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:90886_1_61667
queryTargetObjPlanExDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558731_1_61667
    }

    /*3-3-05查指标扩展规划设置详情[2725]   */
    Assert.isNull(queryTargetObjPlanExDetailReq.getObjectiveId(),"D3查询目标内容预算设置状态详情(公共)-3-3-05查指标扩展规划设置详情-归属指标ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情(公共)-3-3-05查指标扩展规划设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetObjPlanExDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情(公共)-3-3-05查指标扩展规划设置详情-是否存档不能为空",false);
      omsTargetObjectivePlanExtend = mOmsTargetObjectivePlanExtendService.queryTargetObjPlanExDetail(queryTargetObjPlanExDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    if(omsTargetObjectivePlanExtend !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(omsTargetObjectivePlanExtend!=null){
      receptionServiceReq.setIsOpenBudget(omsTargetObjectivePlanExtend.getIsUseBudget());//SimpleFieldAssign//sourceId:1558734_1_61668
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getIsOpenBudget(),"D3查询目标内容预算设置状态详情(公共)-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes = nbFinance.implementFiveReceivingField(receptionServiceReq);


      receptionServiceRes_1 = receptionServiceRes;
           }
      }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET_CATEGORY"))){
       //elseif(D3查询目标内容预算设置状态详情.内容表类型编码 等于 目标分类表)  61669

OmsTargetCategoryExtend omsTargetCategoryExtend = null;
    QueryTargetCatExSetDetailReq queryTargetCatExSetDetailReq=new QueryTargetCatExSetDetailReq();
  queryTargetCatExSetDetailReq.setIsArchive("FALSE");//sourceId:1558786_1_61670
queryTargetCatExSetDetailReq.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1558787_1_61670
if(reqDto!=null){
      queryTargetCatExSetDetailReq.setTargetCategoryId(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1558784_1_61670
queryTargetCatExSetDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558785_1_61670
    }

    /*3-3-02-01查询目标分类扩展设置详情[3294]   */
    Assert.isNull(queryTargetCatExSetDetailReq.getTargetCategoryId(),"D3查询目标内容预算设置状态详情(公共)-3-3-02-01查询目标分类扩展设置详情-归属目标分类ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情(公共)-3-3-02-01查询目标分类扩展设置详情-冗余评价模板ID不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情(公共)-3-3-02-01查询目标分类扩展设置详情-是否存档不能为空",false);
Assert.isNull(queryTargetCatExSetDetailReq.getSpaceId(),"D3查询目标内容预算设置状态详情(公共)-3-3-02-01查询目标分类扩展设置详情-创建于空间ID不能为空",false);
      omsTargetCategoryExtend = mOmsTargetCategoryExtendService.queryTargetCatExSetDetail(queryTargetCatExSetDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_2 = null;
    if(omsTargetCategoryExtend !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(omsTargetCategoryExtend!=null){
      receptionServiceReq_1.setIsOpenBudget(omsTargetCategoryExtend.getIsUseBudget());//SimpleFieldAssign//sourceId:1558734_1_61671
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getIsOpenBudget(),"D3查询目标内容预算设置状态详情(公共)-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes_2 = nbFinance.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_1 = receptionServiceRes_2;
           }
    }
else if((reqDto!= null&&  reqDto.getTableTypeCode() !=null && reqDto.getTableTypeCode().equals("OMS_TARGET"))){
       //elseif(D3查询目标内容预算设置状态详情.内容表类型编码 等于 目标表)  61672

OmsEvaluationTemplate omsEvaluationTemplate = null;
    QueryEvaTempDetailReq queryEvaTempDetailReq=new QueryEvaTempDetailReq();
  queryEvaTempDetailReq.setIsArchive("FALSE");//sourceId:1558789_1_61673
if(reqDto!=null){
      queryEvaTempDetailReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1558788_1_61673
    }

    /*3-2-02查评价模板详情[2316]   */
    Assert.isNull(queryEvaTempDetailReq.getEvaluationTemplateId(),"D3查询目标内容预算设置状态详情(公共)-3-2-02查评价模板详情-评价模板ID不能为空",false);
Assert.isNull(queryEvaTempDetailReq.getIsArchive(),"D3查询目标内容预算设置状态详情(公共)-3-2-02查评价模板详情-是否存档不能为空",false);
      omsEvaluationTemplate = mOmsEvaluationTemplateService.queryEvaTempDetail(queryEvaTempDetailReq)/*vcase invoke 本地 method 方法调用;*/;



//ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_3 = null;
    if(omsEvaluationTemplate !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_2=new ImplementFiveReceivingFieldReqDto();
  if(omsEvaluationTemplate!=null){
      receptionServiceReq_2.setIsOpenBudget(omsEvaluationTemplate.getIsOpenBudget());//SimpleFieldAssign//sourceId:1558734_1_61674
    }

    /*M3接收是否开启预算[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getIsOpenBudget(),"D3查询目标内容预算设置状态详情(公共)-M3接收是否开启预算-是否开启预算不能为空",false);
      receptionServiceRes_3 = nbFinance.implementFiveReceivingField(receptionServiceReq_2);


      receptionServiceRes_1 = receptionServiceRes_3;
           }
    }
QueryTargetContentBudgetStateDetailComRespDto retData = new QueryTargetContentBudgetStateDetailComRespDto();
  if(receptionServiceRes_1!=null){
      retData.setIsOpenBudget(receptionServiceRes_1.getIsOpenBudget());//SimpleFieldAssign//sourceId:1558791_1
    }




return retData;
  }
/**
   * D3执行生成账单业务故事及科目信息(公共)[8538]
   * gen by moon at 9/9/2024, 3:34:00 PM
   */
  @Trace(operationName = "D3执行生成账单业务故事及科目信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto implementGenerateBillBusinessStoriesAndAccountInfoCom(ImplementGenerateBillBusinessStoriesAndAccountInfoComReqDto reqDto){


      QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto_1 =null;
GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto_1 =null;
ObtainCurrentContentAccountInfoComRespDto obtainCurrentContentAccountInfoComRespDto_1 =null;
ImplementFiveReceivingFieldRespDto receptionServiceRes_2 =null;
//步骤0: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes = null;
    ImplementFiveReceivingFieldReqDto receptionServiceReq=new ImplementFiveReceivingFieldReqDto();
  if(reqDto!=null){
      receptionServiceReq.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1562989_1
receptionServiceReq.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1563144_1
receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1562990_1
    }

    /*M3接收字段[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getEvaObjTargetCycleId(),"D3执行生成账单业务故事及科目信息(公共)-M3接收字段-被评对象目标周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getUpdateCycleId(),"D3执行生成账单业务故事及科目信息(公共)-M3接收字段-更新周期ID不能为空",false);
Assert.isNull(receptionServiceReq.getEvaluationTemplateId(),"D3执行生成账单业务故事及科目信息(公共)-M3接收字段-冗余评价模板ID不能为空",false);
      receptionServiceRes = nbFinance.implementFiveReceivingField(receptionServiceReq);




//步骤1: D4-1查标准数据详情(公共) - queryStandardDataDetailCom
     QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setIsUpdateCycleNewData("TRUE");//sourceId:1564308_1
queryStandardDataDetailComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1563059_1
queryStandardDataDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1563063_1
queryStandardDataDetailComReqDto.setIsArchive("FALSE");//sourceId:1563066_1
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1563064_1
queryStandardDataDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1563060_1
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1563065_1
    }

    /*D4查提交的预算支出标准数据(用于获取科目ID)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getUpdateCycleId(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsUpdateCycleNewData(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-是否更新周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsArchive(),"D3执行生成账单业务故事及科目信息(公共)-D4查提交的预算支出标准数据(用于获取科目ID)-是否存档不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;
      Assert.isTrue(queryStandardDataDetailComRespDto== null||  queryStandardDataDetailComRespDto.getDataResult() ==null||queryStandardDataDetailComRespDto== null||  queryStandardDataDetailComRespDto.getExtendedField5() ==null,"找不到数据，系统异常",false);

      queryStandardDataDetailComRespDto_1 = queryStandardDataDetailComRespDto;

//步骤2: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
     QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto = null;
          QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto=new QueryAccountSubjectDetailComReqDto();
  queryAccountSubjectDetailComReqDto.setAccountSubjectCode("AS_BUDGET_EXPENDITURE");//CUSTOM_CONVENTION//sourceId:1565172_1
queryAccountSubjectDetailComReqDto.setIncomeExpensesType("SPENDING");//sourceId:1565173_1
queryAccountSubjectDetailComReqDto.setAccountSubjectClassCode("BUDEGT_ACCOUNT_CLASS");//sourceId:1565151_1
queryAccountSubjectDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1565158_1

    /*D7查预算资金支出科目ID[7709]   */
    Assert.isNull(queryAccountSubjectDetailComReqDto.getAccountSubjectCode(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算资金支出科目ID-科目标识不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getIncomeExpensesType(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算资金支出科目ID-收支类型不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getAccountSubjectClassCode(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算资金支出科目ID-科目类别编码不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto.getSubjectLifeCycle(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算资金支出科目ID-主体生命周期不能为空",false);
      queryAccountSubjectDetailComRespDto = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤3: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
     QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto_2 = null;
    QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto_1=new QueryAccountSubjectDetailComReqDto();
  queryAccountSubjectDetailComReqDto_1.setAccountSubjectCode("AS_BUDGET_EXPENSES_RECEIVED");//CUSTOM_CONVENTION//sourceId:1567664_1
queryAccountSubjectDetailComReqDto_1.setIncomeExpensesType("INCOME");//sourceId:1567666_1
queryAccountSubjectDetailComReqDto_1.setAccountSubjectClassCode("BUDEGT_ACCOUNT_CLASS");//sourceId:1567648_1
queryAccountSubjectDetailComReqDto_1.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1567655_1

    /*D7查预算费用到账科目ID[7709]   */
    Assert.isNull(queryAccountSubjectDetailComReqDto_1.getAccountSubjectCode(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算费用到账科目ID-科目标识不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto_1.getIncomeExpensesType(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算费用到账科目ID-收支类型不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto_1.getAccountSubjectClassCode(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算费用到账科目ID-科目类别编码不能为空",false);
Assert.isNull(queryAccountSubjectDetailComReqDto_1.getSubjectLifeCycle(),"D3执行生成账单业务故事及科目信息(公共)-D7查预算费用到账科目ID-主体生命周期不能为空",false);
      queryAccountSubjectDetailComRespDto_2 = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;




//步骤4: D7查财务科目详情(公共) - queryAccountSubjectDetailCom
     QueryAccountSubjectDetailComRespDto queryAccountSubjectDetailComRespDto_4 = null;
  if(queryStandardDataDetailComRespDto!=null){
          QueryAccountSubjectDetailComReqDto queryAccountSubjectDetailComReqDto_2=new QueryAccountSubjectDetailComReqDto();
  if(queryStandardDataDetailComRespDto!=null){
      queryAccountSubjectDetailComReqDto_2.setAccountSubjectld(queryStandardDataDetailComRespDto.getExtendedField5());//SimpleFieldAssign//sourceId:1562836_1
    }

    /*D7查科目详情(用于生成账单业务故事)[7709]   */
    Assert.isNull(queryAccountSubjectDetailComReqDto_2.getAccountSubjectld(),"D3执行生成账单业务故事及科目信息(公共)-D7查科目详情(用于生成账单业务故事)-科目ID不能为空",false);
      queryAccountSubjectDetailComRespDto_4 = fwFinanceFinanceClient.queryAccountSubjectDetailCom(queryAccountSubjectDetailComReqDto_2).getData()/*vcase invoke 跨dubbo调用;*/;



           }

//步骤5: D2生成语义实例故事(公共) - generateSemanticInstanceStoryCom
     GenerateSemanticInstanceStoryComRespDto generateSemanticInstanceStoryComRespDto = null;
    if(queryAccountSubjectDetailComRespDto_4 !=null){
          GenerateSemanticInstanceStoryComReqDto generateSemanticInstanceStoryComReqDto=new GenerateSemanticInstanceStoryComReqDto();
  generateSemanticInstanceStoryComReqDto.setTemplateSemanticEngineCode("CHARGE_EXPENDITURE_STORY");//CUSTOM_CONVENTION//sourceId:1562899_1
generateSemanticInstanceStoryComReqDto.setFirstFieldName("accountSubjectName");//CUSTOM_CONVENTION//sourceId:1562893_1
if(queryAccountSubjectDetailComRespDto_4!=null){
      generateSemanticInstanceStoryComReqDto.setFirstFieldValue(queryAccountSubjectDetailComRespDto_4.getAccountSubjectName());//SimpleFieldAssign//sourceId:1562894_1
    }

    /*D2生成账单流水业务故事（公共）[8234]   */
    Assert.isNull(generateSemanticInstanceStoryComReqDto.getTemplateSemanticEngineCode(),"D3执行生成账单业务故事及科目信息(公共)-D2生成账单流水业务故事（公共）-模板引擎标识不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldName(),"D3执行生成账单业务故事及科目信息(公共)-D2生成账单流水业务故事（公共）-第一个字段字段名不能为空",false);
Assert.isNull(generateSemanticInstanceStoryComReqDto.getFirstFieldValue(),"D3执行生成账单业务故事及科目信息(公共)-D2生成账单流水业务故事（公共）-第一个字段字段值不能为空",false);
      generateSemanticInstanceStoryComRespDto = fwCompTemplateEngineClient.generateSemanticInstanceStoryCom(generateSemanticInstanceStoryComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      generateSemanticInstanceStoryComRespDto_1 = generateSemanticInstanceStoryComRespDto;
           }

//步骤6: D7获取当前内容账户信息(公共) - obtainCurrentContentAccountInfoCom
     ObtainCurrentContentAccountInfoComRespDto obtainCurrentContentAccountInfoComRespDto = null;
    if(queryStandardDataDetailComRespDto !=null){
          ObtainCurrentContentAccountInfoComReqDto obtainCurrentContentAccountInfoComReqDto=new ObtainCurrentContentAccountInfoComReqDto();
  obtainCurrentContentAccountInfoComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1569481_1
if(queryStandardDataDetailComRespDto!=null){
      obtainCurrentContentAccountInfoComReqDto.setAccountObjectId(queryStandardDataDetailComRespDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1569479_1
    }
if(reqDto!=null){
      obtainCurrentContentAccountInfoComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1569480_1
    }

    /*D7获取当前内容账户信息(公共)[8562]   */
    Assert.isNull(obtainCurrentContentAccountInfoComReqDto.getAccountObjectId(),"D3执行生成账单业务故事及科目信息(公共)-D7获取当前内容账户信息(公共)-关联归属主体ID不能为空",false);
Assert.isNull(obtainCurrentContentAccountInfoComReqDto.getThemeContentId(),"D3执行生成账单业务故事及科目信息(公共)-D7获取当前内容账户信息(公共)-主题内容ID不能为空",false);
Assert.isNull(obtainCurrentContentAccountInfoComReqDto.getSpaceId(),"D3执行生成账单业务故事及科目信息(公共)-D7获取当前内容账户信息(公共)-创建于空间ID不能为空",false);
      obtainCurrentContentAccountInfoComRespDto = fwFinanceFinanceClient.obtainCurrentContentAccountInfoCom(obtainCurrentContentAccountInfoComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      obtainCurrentContentAccountInfoComRespDto_1 = obtainCurrentContentAccountInfoComRespDto;
           }

//步骤7: M3-执行第五接收字段（特殊方法） - implementFiveReceivingField
     //ModelCode: receptionService
        ImplementFiveReceivingFieldRespDto receptionServiceRes_1 = null;
    if(queryStandardDataDetailComRespDto !=null){
          ImplementFiveReceivingFieldReqDto receptionServiceReq_1=new ImplementFiveReceivingFieldReqDto();
  if(queryStandardDataDetailComRespDto!=null){
      receptionServiceReq_1.setBillAmount(queryStandardDataDetailComRespDto.getDataResult());//SimpleFieldAssign//sourceId:1567927_1
    }
if(queryAccountSubjectDetailComRespDto!=null){
      receptionServiceReq_1.setCustomField1(queryAccountSubjectDetailComRespDto.getAccountSubjectld());//SimpleFieldAssign//sourceId:1567753_1
    }
if(queryAccountSubjectDetailComRespDto_2!=null){
      receptionServiceReq_1.setCustomField2(queryAccountSubjectDetailComRespDto_2.getAccountSubjectld());//SimpleFieldAssign//sourceId:1567754_1
    }
if(queryAccountSubjectDetailComRespDto_4!=null){
      receptionServiceReq_1.setCustomField3(queryAccountSubjectDetailComRespDto_4.getAccountSubjectld());//SimpleFieldAssign//sourceId:1567755_1
    }

    /*M3接收账单金额及科目ID[8467]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getBillAmount(),"D3执行生成账单业务故事及科目信息(公共)-M3接收账单金额及科目ID-账单金额不能为空",false);
Assert.isNull(receptionServiceReq_1.getCustomField1(),"D3执行生成账单业务故事及科目信息(公共)-M3接收账单金额及科目ID-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq_1.getCustomField2(),"D3执行生成账单业务故事及科目信息(公共)-M3接收账单金额及科目ID-自定义字段2不能为空",false);
Assert.isNull(receptionServiceReq_1.getCustomField3(),"D3执行生成账单业务故事及科目信息(公共)-M3接收账单金额及科目ID-自定义字段3不能为空",false);
      receptionServiceRes_1 = nbFinance.implementFiveReceivingField(receptionServiceReq_1);


      receptionServiceRes_2 = receptionServiceRes_1;
           }

ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto retData = new ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto();
  if(obtainCurrentContentAccountInfoComRespDto_1!=null){
      retData.setBudgetAccountId(obtainCurrentContentAccountInfoComRespDto_1.getBudgetAccountId());//SimpleFieldAssign//sourceId:1569488_1
retData.setEntityAccountId(obtainCurrentContentAccountInfoComRespDto_1.getEntityAccountId());//SimpleFieldAssign//sourceId:1569489_1
retData.setRelSubBudgetAccountId(obtainCurrentContentAccountInfoComRespDto_1.getRelSubBudgetAccountId());//SimpleFieldAssign//sourceId:1785995_1
retData.setIsIncomingAccount(obtainCurrentContentAccountInfoComRespDto_1.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1569490_1
retData.setRelSubBudgetAccountCode(obtainCurrentContentAccountInfoComRespDto_1.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1569491_1
    }
if(receptionServiceRes_2!=null){
      retData.setBillAmount(receptionServiceRes_2.getBillAmount());//SimpleFieldAssign//sourceId:1567929_1
retData.setFundUsageSubjectld(receptionServiceRes_2.getCustomField3());//SimpleFieldAssign//sourceId:1567912_1
retData.setBudgetExpenditureAsld(receptionServiceRes_2.getCustomField1());//SimpleFieldAssign//sourceId:1567910_1
retData.setBudgetExpensesReceivedAsId(receptionServiceRes_2.getCustomField2());//SimpleFieldAssign//sourceId:1567911_1
    }
if(generateSemanticInstanceStoryComRespDto_1!=null){
      retData.setStoryBillBusiness(generateSemanticInstanceStoryComRespDto_1.getObjectName());//SimpleFieldAssign//sourceId:1562905_1
    }
if(queryStandardDataDetailComRespDto_1!=null){
      retData.setOperationInductionId(queryStandardDataDetailComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1568830_1
    }




return retData;
  }
/**
   * D3执行财务数据处理判断(公共)[8546]
   * gen by moon at 7/3/2024, 6:24:33 PM
   */
  @Trace(operationName = "D3执行财务数据处理判断(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementFinancialDataProcessingComRespDto implementFinancialDataProcessingCom(ImplementFinancialDataProcessingComReqDto reqDto){


      QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto_1 =null;
AnalysisParentSubMidCycleTypeTakeDownComRespDto analysisParentSubMidCycleTypeTakeDownComRespDto_1 =null;
AnalysisIsClearReportTaskSchedulEtcComRespDto analysisIsClearReportTaskSchedulEtcComRespDto_1 =null;
//virtualUsage D3查询目标内容执行周期详情(公共)  69218
      QueryTargetContexeCuteCycleDetailComRespDto queryTargetContexeCuteCycleDetailComRespDto = null;
    QueryTargetContexeCuteCycleDetailComReqDto queryTargetContexeCuteCycleDetailComReqDto=new QueryTargetContexeCuteCycleDetailComReqDto();
  if(reqDto!=null){
      queryTargetContexeCuteCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1820524_1_69218
queryTargetContexeCuteCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1820522_1_69218
queryTargetContexeCuteCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1820523_1_69218
    }

    /*D3查询目标内容执行周期详情(公共)[9661]   */
    Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getCycleId(),"D3执行财务数据处理判断(公共)-D3查询目标内容执行周期详情(公共)-周期ID不能为空",false);
Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3执行财务数据处理判断(公共)-D3查询目标内容执行周期详情(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryTargetContexeCuteCycleDetailComReqDto.getEvaluationTemplateId(),"D3执行财务数据处理判断(公共)-D3查询目标内容执行周期详情(公共)-冗余评价模板ID不能为空",false);
      queryTargetContexeCuteCycleDetailComRespDto = executeCycleService.queryTargetContexeCuteCycleDetailCom(queryTargetContexeCuteCycleDetailComReqDto)/*vcase invoke isSameApp*/;


      queryTargetContexeCuteCycleDetailComRespDto_1 = queryTargetContexeCuteCycleDetailComRespDto;
//virtualUsage D3分析父子中周期类型取小(公共)  69703
      AnalysisParentSubMidCycleTypeTakeDownComRespDto analysisParentSubMidCycleTypeTakeDownComRespDto = null;
    if(queryTargetContexeCuteCycleDetailComRespDto !=null){
          AnalysisParentSubMidCycleTypeTakeDownComReqDto analysisParentSubMidCycleTypeTakeDownComReqDto=new AnalysisParentSubMidCycleTypeTakeDownComReqDto();
  if(reqDto!=null){
      analysisParentSubMidCycleTypeTakeDownComReqDto.setPeriodicModeTypeCode(reqDto.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1852082_1_69703
analysisParentSubMidCycleTypeTakeDownComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1852083_1_69703
analysisParentSubMidCycleTypeTakeDownComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1852085_1_69703
    }
if(queryTargetContexeCuteCycleDetailComRespDto!=null){
      analysisParentSubMidCycleTypeTakeDownComReqDto.setCycleTypeCode(queryTargetContexeCuteCycleDetailComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1852084_1_69703
    }

    /*D3分析父子中周期类型取小(公共)[9453]   */
    Assert.isNull(analysisParentSubMidCycleTypeTakeDownComReqDto.getPeriodicModeTypeCode(),"D3执行财务数据处理判断(公共)-D3分析父子中周期类型取小(公共)-周期模式类型编码不能为空",false);
Assert.isNull(analysisParentSubMidCycleTypeTakeDownComReqDto.getEvaObjTargetCycleId(),"D3执行财务数据处理判断(公共)-D3分析父子中周期类型取小(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisParentSubMidCycleTypeTakeDownComReqDto.getCycleTypeCode(),"D3执行财务数据处理判断(公共)-D3分析父子中周期类型取小(公共)-周期类型标识不能为空",false);
Assert.isNull(analysisParentSubMidCycleTypeTakeDownComReqDto.getEvaluationTemplateId(),"D3执行财务数据处理判断(公共)-D3分析父子中周期类型取小(公共)-冗余评价模板ID不能为空",false);
      analysisParentSubMidCycleTypeTakeDownComRespDto = targetCalcService.analysisParentSubMidCycleTypeTakeDownCom(analysisParentSubMidCycleTypeTakeDownComReqDto)/*vcase invoke isSameApp*/;


      analysisParentSubMidCycleTypeTakeDownComRespDto_1 = analysisParentSubMidCycleTypeTakeDownComRespDto;
           }
//virtualUsage D3分析是否清理汇报任务调度等(公共)  68006
      AnalysisIsClearReportTaskSchedulEtcComRespDto analysisIsClearReportTaskSchedulEtcComRespDto = null;
    if(queryTargetContexeCuteCycleDetailComRespDto !=null){
          AnalysisIsClearReportTaskSchedulEtcComReqDto analysisIsClearReportTaskSchedulEtcComReqDto=new AnalysisIsClearReportTaskSchedulEtcComReqDto();
  if(reqDto!=null){
      analysisIsClearReportTaskSchedulEtcComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1779135_1_68006
analysisIsClearReportTaskSchedulEtcComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1779137_1_68006
    }
if(queryTargetContexeCuteCycleDetailComRespDto!=null){
      analysisIsClearReportTaskSchedulEtcComReqDto.setIsLastCycle(queryTargetContexeCuteCycleDetailComRespDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1779136_1_68006
    }

    /*D3分析是否清理汇报任务调度等(公共)[9504]   */
    Assert.isNull(analysisIsClearReportTaskSchedulEtcComReqDto.getCycleStageDataId(),"D3执行财务数据处理判断(公共)-D3分析是否清理汇报任务调度等(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(analysisIsClearReportTaskSchedulEtcComReqDto.getIsLastCycle(),"D3执行财务数据处理判断(公共)-D3分析是否清理汇报任务调度等(公共)-是否末级周期不能为空",false);
Assert.isNull(analysisIsClearReportTaskSchedulEtcComReqDto.getThemeContentId(),"D3执行财务数据处理判断(公共)-D3分析是否清理汇报任务调度等(公共)-主题内容ID不能为空",false);
      analysisIsClearReportTaskSchedulEtcComRespDto = targetCalcService.analysisIsClearReportTaskSchedulEtcCom(analysisIsClearReportTaskSchedulEtcComReqDto)/*vcase invoke isSameApp*/;


      analysisIsClearReportTaskSchedulEtcComRespDto_1 = analysisIsClearReportTaskSchedulEtcComRespDto;
           }
ImplementFinancialDataProcessingComRespDto retData = new ImplementFinancialDataProcessingComRespDto();
  if(analysisIsClearReportTaskSchedulEtcComRespDto_1!=null){
      retData.setIsClearReportTaskSchedulEtc(analysisIsClearReportTaskSchedulEtcComRespDto_1.getIsClearReportTaskSchedulEtc());//SimpleFieldAssign//sourceId:1779145_1
    }
if(queryTargetContexeCuteCycleDetailComRespDto_1!=null){
      retData.setEvaObjTargetCycleCode(queryTargetContexeCuteCycleDetailComRespDto_1.getEvaObjTargetCycleCode());//SimpleFieldAssign//sourceId:1852099_1
      retData.setCycleStartTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleStartTime());//SimpleFieldAssign//sourceId:1820557_1
retData.setCycleEndTime(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleEndTime());//SimpleFieldAssign//sourceId:1820558_1
retData.setCycleTypeCode(queryTargetContexeCuteCycleDetailComRespDto_1.getCycleTypeCode());//SimpleFieldAssign//sourceId:1820559_1
retData.setIsLastCycle(queryTargetContexeCuteCycleDetailComRespDto_1.getIsLastCycle());//SimpleFieldAssign//sourceId:1820560_1
    }
if(analysisParentSubMidCycleTypeTakeDownComRespDto_1!=null){
      retData.setParentSubMidCycleType(analysisParentSubMidCycleTypeTakeDownComRespDto_1.getParentSubMidCycleType());//SimpleFieldAssign//sourceId:1852093_1
    }




return retData;
  }
/**
   * D3审核汇报材料并更新标准数据(公共)[8555]
   * gen by moon at 10/28/2024, 12:11:08 AM
   */
  @Trace(operationName = "D3审核汇报材料并更新标准数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public ImplementRefreshFullTemplateFinancialDataComRespDto implementRefreshFullTemplateFinancialDataCom(ImplementRefreshFullTemplateFinancialDataComReqDto reqDto){


      //virtualUsage D3获取公共字段入参  62239
      ObtainCalcStartTimeComRespDto obtainCalcStartTimeComRespDto = null;
    ObtainCalcStartTimeComReqDto obtainCalcStartTimeComReqDto=new ObtainCalcStartTimeComReqDto();
  if(reqDto!=null){
obtainCalcStartTimeComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1571428_1_62239
    }

    /*D3获取公共字段入参[8540]   */
Assert.isNull(obtainCalcStartTimeComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3获取公共字段入参-评价模板ID不能为空",false);
      obtainCalcStartTimeComRespDto = standardDataService.obtainCalcStartTimeCom(obtainCalcStartTimeComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D2准备评价模板配置入参(公共)  62238
      ImplementPreEvaTempConfEntParameterComRespDto implementPreEvaTempConfEntParameterComRespDto = null;
    if(obtainCalcStartTimeComRespDto !=null){
          ImplementPreEvaTempConfEntParameterComReqDto implementPreEvaTempConfEntParameterComReqDto=new ImplementPreEvaTempConfEntParameterComReqDto();
  implementPreEvaTempConfEntParameterComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1571398_1_62238
if(reqDto!=null){
      implementPreEvaTempConfEntParameterComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1571396_1_62238
    }
if(obtainCalcStartTimeComRespDto!=null){
      implementPreEvaTempConfEntParameterComReqDto.setEvaluationSubjectId(obtainCalcStartTimeComRespDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1571397_1_62238
    }

    /*D2准备评价模板配置入参(公共)[8567]   */
    Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D2准备评价模板配置入参(公共)-评价模板ID不能为空",false);
Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationSubjectId(),"D3审核汇报材料并更新标准数据(公共)-D2准备评价模板配置入参(公共)-评价主题ID不能为空",false);
Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getSpaceId(),"D3审核汇报材料并更新标准数据(公共)-D2准备评价模板配置入参(公共)-创建于空间ID不能为空",false);
      implementPreEvaTempConfEntParameterComRespDto = fwCompConfSchemeClient.implementPreEvaTempConfEntParameterCom(implementPreEvaTempConfEntParameterComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



           }
//virtualUsage D3分析数据计算正常场景中的正常与异常(公共)  73311
      AnalysisDataCalcNormalAmSceneComRespDto analysisDataCalcNormalAmSceneComRespDto = null;
    AnalysisDataCalcNormalAmSceneComReqDto analysisDataCalcNormalAmSceneComReqDto=new AnalysisDataCalcNormalAmSceneComReqDto();
  if(reqDto!=null){
      analysisDataCalcNormalAmSceneComReqDto.setDataCalcNormalAbnormal(reqDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2024389_1_73311
      analysisDataCalcNormalAmSceneComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:2024123_1_73311
analysisDataCalcNormalAmSceneComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:2024124_1_73311
    }

    /*D3分析数据计算正常场景中的正常与异常(公共)[10284]   */
    Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getDataCalcNormalAbnormal(),"D3审核汇报材料并更新标准数据(公共)-D3分析数据计算正常场景中的正常与异常(公共)-数据计算正常与异常场景不能为空",false);
Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3分析数据计算正常场景中的正常与异常(公共)-周期ID不能为空",false);
    Assert.isNull(analysisDataCalcNormalAmSceneComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3分析数据计算正常场景中的正常与异常(公共)-冗余评价模板ID不能为空",false);
      analysisDataCalcNormalAmSceneComRespDto = evaCalcService.analysisDataCalcNormalAmSceneCom(analysisDataCalcNormalAmSceneComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3新增公共评价模板配置数据(APP推内存)  68174
      AddCommonEvaTempConfDataComRespDto addCommonEvaTempConfDataComRespDto = null;
    if(obtainCalcStartTimeComRespDto !=null&&implementPreEvaTempConfEntParameterComRespDto !=null&&analysisDataCalcNormalAmSceneComRespDto !=null){
          AddCommonEvaTempConfDataComReqDto addCommonEvaTempConfDataComReqDto=new AddCommonEvaTempConfDataComReqDto();
  addCommonEvaTempConfDataComReqDto.setBusinessDataObject("EVA_TEMP_CONF_ARGUMENTS");//sourceId:1785571_1_68174
addCommonEvaTempConfDataComReqDto.setIsDataList("FALSE");//sourceId:1785572_1_68174
if(obtainCalcStartTimeComRespDto!=null){
      addCommonEvaTempConfDataComReqDto.setDataObjectBatchCode(obtainCalcStartTimeComRespDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1785570_1_68174
    }
if(implementPreEvaTempConfEntParameterComRespDto!=null){
      addCommonEvaTempConfDataComReqDto.setCustomFieldValue1(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1785573_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue2(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1785574_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue3(implementPreEvaTempConfEntParameterComRespDto.getUseAccountSubjectType());//SimpleFieldAssign//sourceId:1785575_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue4(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1785576_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue5(implementPreEvaTempConfEntParameterComRespDto.getIsAllowBudgetOverruns());//SimpleFieldAssign//sourceId:1785577_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue6(implementPreEvaTempConfEntParameterComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1785578_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue7(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1785579_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue8(implementPreEvaTempConfEntParameterComRespDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:1785580_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue9(implementPreEvaTempConfEntParameterComRespDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:1785581_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue10(implementPreEvaTempConfEntParameterComRespDto.getReportType());//SimpleFieldAssign//sourceId:1785582_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue11(implementPreEvaTempConfEntParameterComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1785583_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue12(implementPreEvaTempConfEntParameterComRespDto.getFatherCycleType());//SimpleFieldAssign//sourceId:1785584_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue13(implementPreEvaTempConfEntParameterComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1785585_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue14(implementPreEvaTempConfEntParameterComRespDto.getMidCycleType());//SimpleFieldAssign//sourceId:1785586_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue15(implementPreEvaTempConfEntParameterComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1785587_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue16(implementPreEvaTempConfEntParameterComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1785588_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue17(implementPreEvaTempConfEntParameterComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1785589_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue18(implementPreEvaTempConfEntParameterComRespDto.getIsOpenMidProcess());//SimpleFieldAssign//sourceId:1785590_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue19(implementPreEvaTempConfEntParameterComRespDto.getProcessMidCycleType());//SimpleFieldAssign//sourceId:1785591_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue20(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:1785592_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue21(implementPreEvaTempConfEntParameterComRespDto.getConstTaskIsOpenReport());//SimpleFieldAssign//sourceId:1785593_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue22(implementPreEvaTempConfEntParameterComRespDto.getConstIsOpenAtuoReport());//SimpleFieldAssign//sourceId:1785594_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue23(implementPreEvaTempConfEntParameterComRespDto.getNoPracticalValueObjIsProgReport());//SimpleFieldAssign//sourceId:1785595_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue24(implementPreEvaTempConfEntParameterComRespDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1785596_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue25(implementPreEvaTempConfEntParameterComRespDto.getObjectiveActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1785597_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue26(implementPreEvaTempConfEntParameterComRespDto.getActualScoreFormula());//SimpleFieldAssign//sourceId:1785598_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue27(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue()):"");//SimpleFieldAssign//sourceId:1785599_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue28(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveFullMarkUnit());//SimpleFieldAssign//sourceId:1785600_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue29(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint()):"");//SimpleFieldAssign//sourceId:1785601_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue30(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint()):"");//SimpleFieldAssign//sourceId:1785602_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue31(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint()):"");//SimpleFieldAssign//sourceId:1785603_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue32(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint()):"");//SimpleFieldAssign//sourceId:1785604_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue33(implementPreEvaTempConfEntParameterComRespDto.getWeightPoint());//SimpleFieldAssign//sourceId:1785605_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue34(implementPreEvaTempConfEntParameterComRespDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1785606_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue35(implementPreEvaTempConfEntParameterComRespDto.getIncreasesDropDecimalPoint());//SimpleFieldAssign//sourceId:1785607_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue36(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint()):"");//SimpleFieldAssign//sourceId:1785608_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue37(implementPreEvaTempConfEntParameterComRespDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1785634_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue41(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight()):"");//SimpleFieldAssign//sourceId:1785613_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue42(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight()):"");//SimpleFieldAssign//sourceId:1785614_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue43(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight()):"");//SimpleFieldAssign//sourceId:1785615_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue44(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight()):"");//SimpleFieldAssign//sourceId:1785616_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue45(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight()):"");//SimpleFieldAssign//sourceId:1785617_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue46(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight()):"");//SimpleFieldAssign//sourceId:1785618_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue47(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight()):"");//SimpleFieldAssign//sourceId:1785619_1_68174
addCommonEvaTempConfDataComReqDto.setCustomFieldValue48(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight()!=null?String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight()):"");//SimpleFieldAssign//sourceId:1785620_1_68174
    }
if(analysisDataCalcNormalAmSceneComRespDto!=null){
      addCommonEvaTempConfDataComReqDto.setCustomFieldValue57(analysisDataCalcNormalAmSceneComRespDto.getDataCalcNormalAbnormal());//SimpleFieldAssign//sourceId:2022644_1_68174
    }

    /*D3新增公共评价模板配置数据(APP推内存)[9528]   */
    Assert.isNull(addCommonEvaTempConfDataComReqDto.getDataObjectBatchCode(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-数据对象批次标识不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getBusinessDataObject(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-业务数据对象不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getIsDataList(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否是数据集对象不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue1(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否启用预算不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue2(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否开启预算汇报不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue3(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-启用的资金科目类型不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue4(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否开启资金到账不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue5(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否允许预算超支不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue6(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-资金单位不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue7(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-开启财务管理模式不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue8(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-评价模板商业参数不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue9(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-冗余开启OKR场景不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue10(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-汇报类型不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue11(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-周期模式不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue12(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-父周期周期类型不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue13(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-子周期周期类型不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue15(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否开启中期不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue16(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-末级周期类型不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue18(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否开启过程中期不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue20(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-是否开启下级汇报限制不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue21(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-建设任务是否开启汇报不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue22(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-建设任务是否自动汇报不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue23(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-无实际值指标是否开启进度汇报不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue24(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-目标分类实际得分是否开启本级得分不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue25(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-指标目标得分是否开启本级得分不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue26(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-实际得分公式不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue27(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-主观评分满分值不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue28(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-主客观得分单位不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue29(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-得分小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue30(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-达成度小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue31(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-进度小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue32(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-主观得分小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue33(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-权重小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue34(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-权重分小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue35(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-增降幅小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue36(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-实际值小数点规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue37(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-小数最后一位规则不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue41(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-主客观得分_主观得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue42(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-主客观得分_客观得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue43(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-本级过程得分_中期得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue44(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-本级过程得分_过程中期得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue45(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-本级过程得分_最近平均分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue46(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-本级过程得分_主客观得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue47(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-目标得分_本级过程得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue48(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-目标得分_下级目标得分权重不能为空",false);
Assert.isNull(addCommonEvaTempConfDataComReqDto.getCustomFieldValue57(),"D3审核汇报材料并更新标准数据(公共)-D3新增公共评价模板配置数据(APP推内存)-数据计算正常与异常场景不能为空",false);
      addCommonEvaTempConfDataComRespDto = targetCalcService.addCommonEvaTempConfDataCom(addCommonEvaTempConfDataComReqDto)/*vcase invoke isSameApp*/;



           }
//virtualUsage D3执行财务数据处理判断(公共)  62254
      ImplementFinancialDataProcessingComRespDto implementFinancialDataProcessingComRespDto = null;
    if(implementPreEvaTempConfEntParameterComRespDto !=null&&obtainCalcStartTimeComRespDto !=null){
    ImplementFinancialDataProcessingComReqDto implementFinancialDataProcessingComReqDto=new ImplementFinancialDataProcessingComReqDto();
  if(implementPreEvaTempConfEntParameterComRespDto!=null){
      implementFinancialDataProcessingComReqDto.setPeriodicModeTypeCode(implementPreEvaTempConfEntParameterComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1853132_1_62254
    }
  if(reqDto!=null){
      implementFinancialDataProcessingComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1567593_1_62254
implementFinancialDataProcessingComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1779141_1_62254
implementFinancialDataProcessingComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1820566_1_62254
implementFinancialDataProcessingComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1567594_1_62254
implementFinancialDataProcessingComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1567596_1_62254
    }
if(obtainCalcStartTimeComRespDto!=null){
      implementFinancialDataProcessingComReqDto.setTargetId(obtainCalcStartTimeComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1567595_1_62254
    }

    /*D3执行财务数据处理判断(公共)[8546]   */
    Assert.isNull(implementFinancialDataProcessingComReqDto.getPeriodicModeTypeCode(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-周期模式类型编码不能为空",false);
    Assert.isNull(implementFinancialDataProcessingComReqDto.getCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-周期ID不能为空",false);
Assert.isNull(implementFinancialDataProcessingComReqDto.getCycleStageDataId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(implementFinancialDataProcessingComReqDto.getEvaObjTargetCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementFinancialDataProcessingComReqDto.getTargetCycleContentId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-关联目标内容ID不能为空",false);
Assert.isNull(implementFinancialDataProcessingComReqDto.getTargetId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-目标ID不能为空",false);
Assert.isNull(implementFinancialDataProcessingComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3执行财务数据处理判断(公共)-冗余评价模板ID不能为空",false);
      implementFinancialDataProcessingComRespDto = implementFinancialDataProcessingCom(implementFinancialDataProcessingComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D3准备入参：4 分析上一周期ID及上一目标周期ID(公共)  68451
      QueryLastExecCycleAndTargetCycleDetailComRespDto queryLastExecCycleAndTargetCycleDetailComRespDto = null;
    QueryLastExecCycleAndTargetCycleDetailComReqDto queryLastExecCycleAndTargetCycleDetailComReqDto=new QueryLastExecCycleAndTargetCycleDetailComReqDto();
if(reqDto!=null){
      queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1801536_1_68451
queryLastExecCycleAndTargetCycleDetailComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1801537_1_68451
queryLastExecCycleAndTargetCycleDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1801538_1_68451
    }

    /*D3准备入参：4 分析上一周期ID及上一目标周期ID(公共)[7507]   */
    Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaObjTargetCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3准备入参：4 分析上一周期ID及上一目标周期ID(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3准备入参：4 分析上一周期ID及上一目标周期ID(公共)-周期ID不能为空",false);
Assert.isNull(queryLastExecCycleAndTargetCycleDetailComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3准备入参：4 分析上一周期ID及上一目标周期ID(公共)-冗余评价模板ID不能为空",false);
      queryLastExecCycleAndTargetCycleDetailComRespDto = executeCycleService.queryLastExecCycleAndTargetCycleDetailCom(queryLastExecCycleAndTargetCycleDetailComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3数据准备：4 目标内容扩展信息(公共)  68103
      PreparationTargetContExtendInfoComRespDto preparationTargetContExtendInfoComRespDto = null;
          PreparationTargetContExtendInfoComReqDto preparationTargetContExtendInfoComReqDto=new PreparationTargetContExtendInfoComReqDto();
if(reqDto!=null){
    preparationTargetContExtendInfoComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1782395_1_68103
    preparationTargetContExtendInfoComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1782396_1_68103
preparationTargetContExtendInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1782397_1_68103
    }

    /*D3数据准备：4 目标内容扩展信息(公共)[8590]   */
    Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentId(),"D3审核汇报材料并更新标准数据(公共)-D3数据准备：4 目标内容扩展信息(公共)-关联目标内容ID不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getTargetCycleContentTypeCode(),"D3审核汇报材料并更新标准数据(公共)-D3数据准备：4 目标内容扩展信息(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(preparationTargetContExtendInfoComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3数据准备：4 目标内容扩展信息(公共)-冗余评价模板ID不能为空",false);
      preparationTargetContExtendInfoComRespDto = targetCalcService.preparationTargetContExtendInfoCom(preparationTargetContExtendInfoComReqDto)/*vcase invoke isSameApp*/;



//virtualUsage D3分析准备财务入参信息(公共)  71241
      AnalysisPreCurTargetContFinDataComRespDto analysisPreCurTargetContFinDataComRespDto = null;
    if(implementPreEvaTempConfEntParameterComRespDto !=null&&implementFinancialDataProcessingComRespDto !=null){
          AnalysisPreCurTargetContFinDataComReqDto analysisPreCurTargetContFinDataComReqDto=new AnalysisPreCurTargetContFinDataComReqDto();
  if(implementPreEvaTempConfEntParameterComRespDto!=null){
      analysisPreCurTargetContFinDataComReqDto.setIsOpenFinance(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1917341_1_71241
analysisPreCurTargetContFinDataComReqDto.setIsOpenBudget(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1917342_1_71241
analysisPreCurTargetContFinDataComReqDto.setCostReportLevel(implementPreEvaTempConfEntParameterComRespDto.getBudgetReportHierarchy());//SimpleFieldAssign//sourceId:1917343_1_71241
    }
  if(reqDto!=null){
      analysisPreCurTargetContFinDataComReqDto.setUpdateCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1917344_1_71241
analysisPreCurTargetContFinDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1917346_1_71241
analysisPreCurTargetContFinDataComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1917347_1_71241
analysisPreCurTargetContFinDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1917348_1_71241
analysisPreCurTargetContFinDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1917340_1_71241
    }
if(implementFinancialDataProcessingComRespDto!=null){
      analysisPreCurTargetContFinDataComReqDto.setIsLastCycle(implementFinancialDataProcessingComRespDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1917345_1_71241
    }

    /*D3分析准备财务入参信息(公共)[9918]   */
    Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getIsOpenFinance(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-开启财务管理模式不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getIsOpenBudget(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-是否开启预算不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getUpdateCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-更新周期ID不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getIsLastCycle(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-是否末级周期不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getEvaObjTargetCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getTargetCycleContentTypeCode(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getTargetCycleContentId(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisPreCurTargetContFinDataComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3分析准备财务入参信息(公共)-冗余评价模板ID不能为空",false);
      analysisPreCurTargetContFinDataComRespDto = analysisPreCurTargetContFinDataCom(analysisPreCurTargetContFinDataComReqDto)/*vcase invoke 同服务,同domain*/;



           }
//virtualUsage D3准备数据：6当前操作人就职记录ID(公共）  62253
      QueryVirtualOrgMemberDetailComRespDto queryVirtualOrgMemberDetailComRespDto = null;
    QueryVirtualOrgMemberDetailComReqDto queryVirtualOrgMemberDetailComReqDto=new QueryVirtualOrgMemberDetailComReqDto();
  queryVirtualOrgMemberDetailComReqDto.setIsPersonCharge("TRUE");//sourceId:1572461_1_62253
queryVirtualOrgMemberDetailComReqDto.setUseScene("TARGET_PLAN_SCENE");//sourceId:1572463_1_62253
queryVirtualOrgMemberDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1572464_1_62253
if(reqDto!=null){
      queryVirtualOrgMemberDetailComReqDto.setEntityId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1572460_1_62253
queryVirtualOrgMemberDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1572462_1_62253
    }

    /*D3准备数据：6当前操作人就职记录ID(公共）[5937]   */
    Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getEntityId(),"D3审核汇报材料并更新标准数据(公共)-D3准备数据：6当前操作人就职记录ID(公共）-冗余内容表主键ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3准备数据：6当前操作人就职记录ID(公共）-归属对象ID不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getIsPersonCharge(),"D3审核汇报材料并更新标准数据(公共)-D3准备数据：6当前操作人就职记录ID(公共）-是否负责人不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getUseScene(),"D3审核汇报材料并更新标准数据(公共)-D3准备数据：6当前操作人就职记录ID(公共）-虚拟组织使用场景不能为空",false);
Assert.isNull(queryVirtualOrgMemberDetailComReqDto.getSubjectLifeCycle(),"D3审核汇报材料并更新标准数据(公共)-D3准备数据：6当前操作人就职记录ID(公共）-主体生命周期不能为空",false);
      queryVirtualOrgMemberDetailComRespDto = virtualOrgService.queryVirtualOrgMemberDetailCom(queryVirtualOrgMemberDetailComReqDto)/*vcase invoke isSameApp*/;
      Assert.isTrue(queryVirtualOrgMemberDetailComRespDto== null||  queryVirtualOrgMemberDetailComRespDto.getVirtualOrgInductionRecordId() ==null,"找不到数据，系统异常",false);


//virtualUsage D3审核汇报材料并更新数据(公共)  67713
      ApproveReportInfoAndUpdateDataComRespDto approveReportInfoAndUpdateDataComRespDto = null;
    if(analysisPreCurTargetContFinDataComRespDto !=null&&implementFinancialDataProcessingComRespDto !=null&&obtainCalcStartTimeComRespDto !=null&&implementPreEvaTempConfEntParameterComRespDto !=null&&queryLastExecCycleAndTargetCycleDetailComRespDto !=null&&queryVirtualOrgMemberDetailComRespDto !=null&&preparationTargetContExtendInfoComRespDto !=null){
          ApproveReportInfoAndUpdateDataComReqDto approveReportInfoAndUpdateDataComReqDto=new ApproveReportInfoAndUpdateDataComReqDto();
  if(analysisPreCurTargetContFinDataComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setTureOrFalse(analysisPreCurTargetContFinDataComRespDto.getTureOrFalse());//SimpleFieldAssign//sourceId:1920182_1_67713
approveReportInfoAndUpdateDataComReqDto.setBudgetAccountId(analysisPreCurTargetContFinDataComRespDto.getRelSubBudgetAccountId());//SimpleFieldAssign//sourceId:1769057_1_67713
approveReportInfoAndUpdateDataComReqDto.setEntityAccountId(analysisPreCurTargetContFinDataComRespDto.getEntityAccountId());//SimpleFieldAssign//sourceId:1769038_1_67713
approveReportInfoAndUpdateDataComReqDto.setIsIncomingAccount(analysisPreCurTargetContFinDataComRespDto.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1769077_1_67713
approveReportInfoAndUpdateDataComReqDto.setBillAmount(analysisPreCurTargetContFinDataComRespDto.getBillAmount());//SimpleFieldAssign//sourceId:1769058_1_67713
approveReportInfoAndUpdateDataComReqDto.setBillBizStory(analysisPreCurTargetContFinDataComRespDto.getStoryBillBusiness());//SimpleFieldAssign//sourceId:1769078_1_67713
approveReportInfoAndUpdateDataComReqDto.setFundUsageSubjectld(analysisPreCurTargetContFinDataComRespDto.getFundUsageSubjectld());//SimpleFieldAssign//sourceId:1769059_1_67713
approveReportInfoAndUpdateDataComReqDto.setBudgetExpenseSubjectld(analysisPreCurTargetContFinDataComRespDto.getBudgetExpensesReceivedAsId());//SimpleFieldAssign//sourceId:1769060_1_67713
approveReportInfoAndUpdateDataComReqDto.setBudgetExpensesReceivedSubjectld(analysisPreCurTargetContFinDataComRespDto.getBudgetExpensesReceivedAsId());//SimpleFieldAssign//sourceId:1769061_1_67713
approveReportInfoAndUpdateDataComReqDto.setRelSubBudgetAccountCode(analysisPreCurTargetContFinDataComRespDto.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1769079_1_67713
approveReportInfoAndUpdateDataComReqDto.setOppositeName(analysisPreCurTargetContFinDataComRespDto.getAbbreviation());//SimpleFieldAssign//sourceId:1769080_1_67713
approveReportInfoAndUpdateDataComReqDto.setOppositeLogo(analysisPreCurTargetContFinDataComRespDto.getSpaceLogo());//SimpleFieldAssign//sourceId:1769081_1_67713
    }
  if(implementFinancialDataProcessingComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setIsClearReportTaskSchedulEtc(implementFinancialDataProcessingComRespDto.getIsClearReportTaskSchedulEtc());//SimpleFieldAssign//sourceId:1779362_1_67713
approveReportInfoAndUpdateDataComReqDto.setCycleTypeCode(implementFinancialDataProcessingComRespDto.getCycleTypeCode());//SimpleFieldAssign//sourceId:1769112_1_67713
approveReportInfoAndUpdateDataComReqDto.setCycleStartTime(implementFinancialDataProcessingComRespDto.getCycleStartTime());//SimpleFieldAssign//sourceId:1769113_1_67713
approveReportInfoAndUpdateDataComReqDto.setCycleEndTime(implementFinancialDataProcessingComRespDto.getCycleEndTime());//SimpleFieldAssign//sourceId:1769114_1_67713
approveReportInfoAndUpdateDataComReqDto.setIsLastCycle(implementFinancialDataProcessingComRespDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1769036_1_67713
    }
if(obtainCalcStartTimeComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setDataObjectBatchCode(obtainCalcStartTimeComRespDto.getEventBatchUpdateCode());//SimpleFieldAssign//sourceId:1769037_1_67713
approveReportInfoAndUpdateDataComReqDto.setCalcStartTime(obtainCalcStartTimeComRespDto.getCalcStartTime());//SimpleFieldAssign//sourceId:1769121_1_67713
approveReportInfoAndUpdateDataComReqDto.setTargetId(obtainCalcStartTimeComRespDto.getTargetId());//SimpleFieldAssign//sourceId:1782529_1_67713
    }
if(reqDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setExamineOptType(reqDto.getExamineOptType());//SimpleFieldAssign//sourceId:1769031_1_67713
approveReportInfoAndUpdateDataComReqDto.setTaskId(reqDto.getTaskId());//SimpleFieldAssign//sourceId:1769032_1_67713
approveReportInfoAndUpdateDataComReqDto.setCycleStageDataId(reqDto.getCycleStageDataId());//SimpleFieldAssign//sourceId:1823334_1_67713
approveReportInfoAndUpdateDataComReqDto.setCycleId(reqDto.getCycleId());//SimpleFieldAssign//sourceId:1769035_1_67713
approveReportInfoAndUpdateDataComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1769033_1_67713
approveReportInfoAndUpdateDataComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1769127_1_67713
approveReportInfoAndUpdateDataComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1769034_1_67713
    }
if(implementPreEvaTempConfEntParameterComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setIsOpenFundsArrival(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1769039_1_67713
approveReportInfoAndUpdateDataComReqDto.setFundUnit(implementPreEvaTempConfEntParameterComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1769174_1_67713
approveReportInfoAndUpdateDataComReqDto.setOpenMidCycle(implementPreEvaTempConfEntParameterComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1799320_1_67713
approveReportInfoAndUpdateDataComReqDto.setTargetScoreUnit(implementPreEvaTempConfEntParameterComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1769141_1_67713
approveReportInfoAndUpdateDataComReqDto.setIsOpenSymbolicAchievements(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1769156_1_67713
approveReportInfoAndUpdateDataComReqDto.setPeriodicModeTypeCode(implementPreEvaTempConfEntParameterComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1769140_1_67713
    }
if(queryLastExecCycleAndTargetCycleDetailComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setPreUpdateCycleId(queryLastExecCycleAndTargetCycleDetailComRespDto.getLastCycleId());//SimpleFieldAssign//sourceId:1801294_1_67713
    }
if(queryVirtualOrgMemberDetailComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setOperationInductionId(queryVirtualOrgMemberDetailComRespDto.getVirtualOrgInductionRecordId());//SimpleFieldAssign//sourceId:1769162_1_67713
    }
if(preparationTargetContExtendInfoComRespDto!=null){
      approveReportInfoAndUpdateDataComReqDto.setIsOpenCustomExecuteCycle(preparationTargetContExtendInfoComRespDto.getIsOpenCustomExecuteCycle());//SimpleFieldAssign//sourceId:1782528_1_67713
    }

    /*D3审核汇报材料并更新数据(公共)[9479]   */
    Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getTureOrFalse(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-财务是否计算不能为空",false);
    Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getIsClearReportTaskSchedulEtc(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-是否清理汇报任务调度等不能为空",false);
    Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getDataObjectBatchCode(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-数据对象批次标识不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCalcStartTime(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-计算开始时间不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getExamineOptType(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-审核通过或失败操作类型不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getTaskId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-任务ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCycleStageDataId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-周期阶段资料记录ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getIsOpenFundsArrival(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-是否开启资金到账不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getFundUnit(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-资金单位不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getOpenMidCycle(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-是否开启中期不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-归属周期ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCycleTypeCode(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-周期类型标识不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCycleStartTime(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-周期开始时间不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getCycleEndTime(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-周期结束时间不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getIsLastCycle(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-是否末级周期不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getEvaObjTargetCycleId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getTargetCycleContentId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-关联目标内容ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getTargetScoreUnit(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-目标得分单位不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getIsOpenSymbolicAchievements(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-是否开启标志性成果不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getPeriodicModeTypeCode(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-周期模式类型编码不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getTargetId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-冗余目标ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getEvaluationTemplateId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-冗余评价模板ID不能为空",false);
Assert.isNull(approveReportInfoAndUpdateDataComReqDto.getOperationInductionId(),"D3审核汇报材料并更新标准数据(公共)-D3审核汇报材料并更新数据(公共)-操作人就职记录ID不能为空",false);
      approveReportInfoAndUpdateDataComRespDto = targetCalcService.approveReportInfoAndUpdateDataCom(approveReportInfoAndUpdateDataComReqDto)/*vcase invoke isSameApp*/;



      }
ImplementRefreshFullTemplateFinancialDataComRespDto retData = new ImplementRefreshFullTemplateFinancialDataComRespDto();





return retData;
  }
/**
   * D3-提交汇报准备配置入参数据(公共)[8586]
   * gen by moon at 3/13/2024, 5:24:18 AM
   */
  @Trace(operationName = "D3-提交汇报准备配置入参数据(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public CommitBudgetReportDataPreComRespDto commitBudgetReportDataPreCom(CommitBudgetReportDataPreComReqDto reqDto){


      QueryCycleTypeConfDetailComRespDto queryCycleTypeConfDetailComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_1 =null;
QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_3 =null;
//virtualUsage D2-查询周期类型配置详情(公共)  62556
      QueryCycleTypeConfDetailComRespDto queryCycleTypeConfDetailComRespDto = null;
    QueryCycleTypeConfDetailComReqDto queryCycleTypeConfDetailComReqDto=new QueryCycleTypeConfDetailComReqDto();
  if(reqDto!=null){
      queryCycleTypeConfDetailComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1580736_1_62556
    }

    /*D2-查询周期类型配置详情(公共)[8581]   */
    Assert.isNull(queryCycleTypeConfDetailComReqDto.getEvaluationTemplateId(),"D3-提交汇报准备配置入参数据(公共)-D2-查询周期类型配置详情(公共)-冗余评价模板ID不能为空",false);
      queryCycleTypeConfDetailComRespDto = fwCompStandardDataClient.queryCycleTypeConfDetailCom(queryCycleTypeConfDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryCycleTypeConfDetailComRespDto_1 = queryCycleTypeConfDetailComRespDto;
if((reqDto!= null&&  reqDto.getIsOpenBudget() !=null && reqDto.getIsOpenBudget().equals("TRUE")&&reqDto!= null&&  reqDto.getIsOpenBudgetReport() !=null && reqDto.getIsOpenBudgetReport().equals("TRUE"))) {
        //if((D3-提交预算汇报数据准备(公共).是否开启预算 等于 是 and D3-提交预算汇报数据准备(公共).是否开启预算汇报 等于 是))  62515

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("CASH_ACCOUNT_UNIT");//CUSTOM_CONVENTION//sourceId:1580099_1_62516
queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1580100_1_62516
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1580098_1_62516
    }

    /*D2-3查预算金额单位（用于新增标准数据）[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(),"D3-提交汇报准备配置入参数据(公共)-D2-3查预算金额单位（用于新增标准数据）-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(),"D3-提交汇报准备配置入参数据(公共)-D2-3查预算金额单位（用于新增标准数据）-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(),"D3-提交汇报准备配置入参数据(公共)-D2-3查预算金额单位（用于新增标准数据）-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_1 = queryConfItemMatchAnswerDetailComRespDto;
      }
if((reqDto!= null&& reqDto.getSubjectiveMark() != null )) {
        //if(D3-提交汇报准备配置入参数据(公共).主观评分 值不等于空 )  62583

QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
    QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1=new QueryConfItemMatchAnswerDetailComReqDto();
  queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("SUBJECTIVE_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1581087_1_62584
queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1581088_1_62584
if(reqDto!=null){
      queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1581086_1_62584
    }

    /*D2-3查主观评分满分值单位[2486]   */
    Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(),"D3-提交汇报准备配置入参数据(公共)-D2-3查主观评分满分值单位-开通对象ID不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(),"D3-提交汇报准备配置入参数据(公共)-D2-3查主观评分满分值单位-配置项标识不能为空",false);
Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(),"D3-提交汇报准备配置入参数据(公共)-D2-3查主观评分满分值单位-是否标准答案不能为空",false);
      queryConfItemMatchAnswerDetailComRespDto_2 = fwCompConfSchemeClient.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1).getData()/*vcase invoke 跨dubbo调用;*/;


      queryConfItemMatchAnswerDetailComRespDto_3 = queryConfItemMatchAnswerDetailComRespDto_2;
      }
CommitBudgetReportDataPreComRespDto retData = new CommitBudgetReportDataPreComRespDto();
  if(queryCycleTypeConfDetailComRespDto_1!=null){
      retData.setPeriodicModeTypeCode(queryCycleTypeConfDetailComRespDto_1.getPeriodicModeTypeCode());//SimpleFieldAssign//sourceId:1580756_1
retData.setLastCycleType(queryCycleTypeConfDetailComRespDto_1.getLastCycleType());//SimpleFieldAssign//sourceId:1580757_1
retData.setSecondLastCycleType(queryCycleTypeConfDetailComRespDto_1.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1580758_1
retData.setSubcycleType(queryCycleTypeConfDetailComRespDto_1.getSubcycleType());//SimpleFieldAssign//sourceId:1580759_1
//retData.setMidCycleType(queryCycleTypeConfDetailComRespDto_1.getMidCycleType());//SimpleFieldAssign//sourceId:1580760_1
//retData.setFatherCycleType(queryCycleTypeConfDetailComRespDto_1.getFatherCycleType());//SimpleFieldAssign//sourceId:1580761_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_1!=null){
      retData.setBudgetDisburseUnit(queryConfItemMatchAnswerDetailComRespDto_1.getEndValue());//SimpleFieldAssign//sourceId:1580346_1
    }
if(queryConfItemMatchAnswerDetailComRespDto_3!=null){
      retData.setSubjectiveFullMarkUnit(queryConfItemMatchAnswerDetailComRespDto_3.getEndValue());//SimpleFieldAssign//sourceId:1581090_1
    }




return retData;
  }
/**
   * D3分析准备财务入参信息(公共)[9918]
   * gen by moon at 7/4/2024, 12:48:13 AM
   */
  @Trace(operationName = "D3分析准备财务入参信息(公共)")
  @Tags({@Tag(key = "参数",value = "arg[0]"),
            @Tag(key = "返回值",value = "returnedObj")})
  @Transactional(rollbackFor=Exception.class)
  @Override
  public AnalysisPreCurTargetContFinDataComRespDto analysisPreCurTargetContFinDataCom(AnalysisPreCurTargetContFinDataComReqDto reqDto){


      ImplementElevenReceivingFieldRespDto receptionServiceRes_3 =null;
      ImplementIsOrgOfficialAccountNomAnalyzeComRespDto implementIsOrgOfficialAccountNomAnalyzeComRespDto_1 =null;
ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1 =null;
QuerySpaceDetailComRespDto querySpaceDetailComRespDto_1 =null;
//virtualUsage M3-约定字段：是否  71304
      //ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq=new ImplementElevenReceivingFieldReqDto();
  receptionServiceReq.setCustomField1("TRUE");//CUSTOM_CONVENTION//sourceId:1920176_1_71304
receptionServiceReq.setCustomField2("FALSE");//CUSTOM_CONVENTION//sourceId:1920177_1_71304

    /*M3-约定字段：是否[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq.getCustomField1(),"D3分析准备财务入参信息(公共)-M3-约定字段：是否-自定义字段1不能为空",false);
Assert.isNull(receptionServiceReq.getCustomField2(),"D3分析准备财务入参信息(公共)-M3-约定字段：是否-自定义字段2不能为空",false);
      receptionServiceRes = nbFinance.implementElevenReceivingField(receptionServiceReq);



if((reqDto!= null&&  reqDto.getIsOpenBudget() !=null && reqDto.getIsOpenBudget().equals("TRUE")&&reqDto!= null&&  reqDto.getIsLastCycle() !=null && reqDto.getIsLastCycle().equals("TRUE"))) {
        //if((D3分析准备财务入参信息(公共).是否开启预算 等于 是 and D3分析准备财务入参信息(公共).是否末级周期 等于 是))  71230

AnalysisTargetContentIsBudgetReportLevelComRespDto analysisTargetContentIsBudgetReportLevelComRespDto = null;
    AnalysisTargetContentIsBudgetReportLevelComReqDto analysisTargetContentIsBudgetReportLevelComReqDto=new AnalysisTargetContentIsBudgetReportLevelComReqDto();
  if(reqDto!=null){
      analysisTargetContentIsBudgetReportLevelComReqDto.setIsOpenBudget(reqDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1916782_1_71231
analysisTargetContentIsBudgetReportLevelComReqDto.setCostReportLevel(reqDto.getCostReportLevel());//SimpleFieldAssign//sourceId:1916786_1_71231
analysisTargetContentIsBudgetReportLevelComReqDto.setTargetCycleContentTypeCode(reqDto.getTargetCycleContentTypeCode());//SimpleFieldAssign//sourceId:1916783_1_71231
analysisTargetContentIsBudgetReportLevelComReqDto.setTargetCycleContentId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1916784_1_71231
analysisTargetContentIsBudgetReportLevelComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1916785_1_71231
    }

    /*D3分析目标内容是否预算汇报层级(公共)[9917]   */
    Assert.isNull(analysisTargetContentIsBudgetReportLevelComReqDto.getIsOpenBudget(),"D3分析准备财务入参信息(公共)-D3分析目标内容是否预算汇报层级(公共)-是否开启预算不能为空",false);
Assert.isNull(analysisTargetContentIsBudgetReportLevelComReqDto.getTargetCycleContentTypeCode(),"D3分析准备财务入参信息(公共)-D3分析目标内容是否预算汇报层级(公共)-关联目标内容类型编码不能为空",false);
Assert.isNull(analysisTargetContentIsBudgetReportLevelComReqDto.getTargetCycleContentId(),"D3分析准备财务入参信息(公共)-D3分析目标内容是否预算汇报层级(公共)-关联目标内容ID不能为空",false);
Assert.isNull(analysisTargetContentIsBudgetReportLevelComReqDto.getEvaluationTemplateId(),"D3分析准备财务入参信息(公共)-D3分析目标内容是否预算汇报层级(公共)-冗余评价模板ID不能为空",false);
      analysisTargetContentIsBudgetReportLevelComRespDto = indexSystemService.analysisTargetContentIsBudgetReportLevelCom(analysisTargetContentIsBudgetReportLevelComReqDto)/*vcase invoke isSameApp*/;



if((analysisTargetContentIsBudgetReportLevelComRespDto!= null&&  analysisTargetContentIsBudgetReportLevelComRespDto.getIsStatisticalAccount() !=null && analysisTargetContentIsBudgetReportLevelComRespDto.getIsStatisticalAccount().equals("FALSE"))) {
        //if(D3分析目标内容是否预算汇报层级(公共).是否统计账户 等于 否)  71232

QueryFinanceAccountDetailComRespDto queryFinanceAccountDetailComRespDto = null;
    QueryFinanceAccountDetailComReqDto queryFinanceAccountDetailComReqDto=new QueryFinanceAccountDetailComReqDto();
  queryFinanceAccountDetailComReqDto.setIsBudgetAccount("FALSE");//sourceId:1916877_1_71233
queryFinanceAccountDetailComReqDto.setSubjectLifeCycle("CURRENTLY_VALID");//sourceId:1916880_1_71233
queryFinanceAccountDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1916881_1_71233
if(reqDto!=null){
      queryFinanceAccountDetailComReqDto.setAccountObjectId(reqDto.getTargetCycleContentId());//SimpleFieldAssign//sourceId:1916878_1_71233
queryFinanceAccountDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1916879_1_71233
    }

    /*D7-查询资金账户详情(公共)[7681]   */
    Assert.isNull(queryFinanceAccountDetailComReqDto.getIsBudgetAccount(),"D3分析准备财务入参信息(公共)-D7-查询资金账户详情(公共)-是否预算账户不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getAccountObjectId(),"D3分析准备财务入参信息(公共)-D7-查询资金账户详情(公共)-关联归属主体ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getThemeContentId(),"D3分析准备财务入参信息(公共)-D7-查询资金账户详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSubjectLifeCycle(),"D3分析准备财务入参信息(公共)-D7-查询资金账户详情(公共)-主体生命周期不能为空",false);
Assert.isNull(queryFinanceAccountDetailComReqDto.getSpaceId(),"D3分析准备财务入参信息(公共)-D7-查询资金账户详情(公共)-创建于空间ID不能为空",false);
      queryFinanceAccountDetailComRespDto = fwFinanceFinanceClient.queryFinanceAccountDetailCom(queryFinanceAccountDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryFinanceAccountDetailComRespDto!= null&& queryFinanceAccountDetailComRespDto.getAccountId() != null )) {
        //if(D7-查目标内容实体账户详情(公共).账户ID 值不等于空 )  71234

QueryStandardDataDetailComRespDto queryStandardDataDetailComRespDto = null;
    QueryStandardDataDetailComReqDto queryStandardDataDetailComReqDto=new QueryStandardDataDetailComReqDto();
  queryStandardDataDetailComReqDto.setDataType("BUDGET_DISBURSE");//sourceId:1916835_1_71235
queryStandardDataDetailComReqDto.setIsNewData("TRUE");//sourceId:1916838_1_71235
queryStandardDataDetailComReqDto.setDataUsageSceneCode("BUDGET_DATA_STATISTICS");//sourceId:1916836_1_71235
queryStandardDataDetailComReqDto.setIsArchive("FALSE");//sourceId:1916842_1_71235
if(reqDto!=null){
      queryStandardDataDetailComReqDto.setEntityId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1916840_1_71235
queryStandardDataDetailComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1916837_1_71235
queryStandardDataDetailComReqDto.setThemeContentId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1916841_1_71235
    }

    /*D4-1查标准数据详情(公共)[2695]   */
    Assert.isNull(queryStandardDataDetailComReqDto.getEntityId(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-归属内容表主键ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getUpdateCycleId(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-更新周期ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getThemeContentId(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-主题内容ID不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataType(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-数据点类型不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsNewData(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-是否归属周期最新数据不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getDataUsageSceneCode(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-数据业务场景不能为空",false);
Assert.isNull(queryStandardDataDetailComReqDto.getIsArchive(),"D3分析准备财务入参信息(公共)-D4-1查标准数据详情(公共)-是否存档不能为空",false);
      queryStandardDataDetailComRespDto = fwCalcStandardDataClient.queryStandardDataDetailCom(queryStandardDataDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;



if((queryStandardDataDetailComRespDto!= null&& queryStandardDataDetailComRespDto.getDataResult() != null )) {
        //if(D4-1查汇报提交的预算支出金额标准数据(公共).数据值结果 值不等于空 )  71236

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_2 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_1=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_1.setTureOrFalse(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1919861_1_71303
    }

    /*M3-接收出参字段：财务是否计算[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_1.getTureOrFalse(),"D3分析准备财务入参信息(公共)-M3-接收出参字段：财务是否计算-是否不能为空",false);
      receptionServiceRes_2 = nbFinance.implementElevenReceivingField(receptionServiceReq_1);


      receptionServiceRes_3 = receptionServiceRes_2;
ImplementIsOrgOfficialAccountNomAnalyzeComRespDto implementIsOrgOfficialAccountNomAnalyzeComRespDto = null;
    ImplementIsOrgOfficialAccountNomAnalyzeComReqDto implementIsOrgOfficialAccountNomAnalyzeComReqDto=new ImplementIsOrgOfficialAccountNomAnalyzeComReqDto();
  if(reqDto!=null){
      implementIsOrgOfficialAccountNomAnalyzeComReqDto.setEndValue(reqDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1916883_1_71237
    }

    /*D7执行是否组织正式财务标准分析(公共)[8047]   */
    Assert.isNull(implementIsOrgOfficialAccountNomAnalyzeComReqDto.getEndValue(),"D3分析准备财务入参信息(公共)-D7执行是否组织正式财务标准分析(公共)-空间开启财务模式答案不能为空",false);
      implementIsOrgOfficialAccountNomAnalyzeComRespDto = fwFinanceFinanceClient.implementIsOrgOfficialAccountNomAnalyzeCom(implementIsOrgOfficialAccountNomAnalyzeComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      implementIsOrgOfficialAccountNomAnalyzeComRespDto_1 = implementIsOrgOfficialAccountNomAnalyzeComRespDto;
ImplementGenerateBillBusinessStoriesAndAccountInfoComRespDto implementGenerateBillBusinessStoriesAndAccountInfoComRespDto = null;
    ImplementGenerateBillBusinessStoriesAndAccountInfoComReqDto implementGenerateBillBusinessStoriesAndAccountInfoComReqDto=new ImplementGenerateBillBusinessStoriesAndAccountInfoComReqDto();
  if(reqDto!=null){
      implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setEvaObjTargetCycleId(reqDto.getEvaObjTargetCycleId());//SimpleFieldAssign//sourceId:1916886_1_71238
implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setUpdateCycleId(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1916888_1_71238
implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1916887_1_71238
    }

    /*D3执行生成账单业务故事及科目信息(公共)[8538]   */
    Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getEvaObjTargetCycleId(),"D3分析准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-被评对象目标周期ID不能为空",false);
Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getUpdateCycleId(),"D3分析准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-更新周期ID不能为空",false);
Assert.isNull(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto.getEvaluationTemplateId(),"D3分析准备财务入参信息(公共)-D3执行生成账单业务故事及科目信息(公共)-冗余评价模板ID不能为空",false);
      implementGenerateBillBusinessStoriesAndAccountInfoComRespDto = implementGenerateBillBusinessStoriesAndAccountInfoCom(implementGenerateBillBusinessStoriesAndAccountInfoComReqDto)/*vcase invoke 同服务,同domain*/;


      implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1 = implementGenerateBillBusinessStoriesAndAccountInfoComRespDto;
QuerySpaceDetailComRespDto querySpaceDetailComRespDto = null;
    QuerySpaceDetailComReqDto querySpaceDetailComReqDto=new QuerySpaceDetailComReqDto();
  querySpaceDetailComReqDto.setSpaceId(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1916925_1_71239

    /*D1-2查空间详情(公共)[402]   */
    Assert.isNull(querySpaceDetailComReqDto.getSpaceId(),"D3分析准备财务入参信息(公共)-D1-2查空间详情(公共)-空间ID不能为空",false);
      querySpaceDetailComRespDto = fwBaseBaseClient.querySpaceDetailCom(querySpaceDetailComReqDto).getData()/*vcase invoke 跨dubbo调用;*/;


      querySpaceDetailComRespDto_1 = querySpaceDetailComRespDto;
      }
else{
       //else  71305

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_4 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_2=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_2.setTureOrFalse(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1919861_1_71306
    }

    /*M3-接收出参字段：财务是否计算[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_2.getTureOrFalse(),"D3分析准备财务入参信息(公共)-M3-接收出参字段：财务是否计算-是否不能为空",false);
      receptionServiceRes_4 = nbFinance.implementElevenReceivingField(receptionServiceReq_2);


      receptionServiceRes_3 = receptionServiceRes_4;
    }
      }
else{
       //else  71307

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_5 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_3=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_3.setTureOrFalse(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1919861_1_71308
    }

    /*M3-接收出参字段：财务是否计算[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_3.getTureOrFalse(),"D3分析准备财务入参信息(公共)-M3-接收出参字段：财务是否计算-是否不能为空",false);
      receptionServiceRes_5 = nbFinance.implementElevenReceivingField(receptionServiceReq_3);


      receptionServiceRes_3 = receptionServiceRes_5;
    }
      }
else{
       //else  71309

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_6 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_4=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_4.setTureOrFalse(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1919861_1_71310
    }

    /*M3-接收出参字段：财务是否计算[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_4.getTureOrFalse(),"D3分析准备财务入参信息(公共)-M3-接收出参字段：财务是否计算-是否不能为空",false);
      receptionServiceRes_6 = nbFinance.implementElevenReceivingField(receptionServiceReq_4);


      receptionServiceRes_3 = receptionServiceRes_6;
      }
      }
else{
       //else  71311

//ModelCode: receptionService
        ImplementElevenReceivingFieldRespDto receptionServiceRes_7 = null;
    ImplementElevenReceivingFieldReqDto receptionServiceReq_5=new ImplementElevenReceivingFieldReqDto();
  if(receptionServiceRes!=null){
      receptionServiceReq_5.setTureOrFalse(receptionServiceRes.getCustomField2());//SimpleFieldAssign//sourceId:1919861_1_71312
    }

    /*M3-接收出参字段：财务是否计算[9482]  用于特殊方法接收上游入参。 */
    Assert.isNull(receptionServiceReq_5.getTureOrFalse(),"D3分析准备财务入参信息(公共)-M3-接收出参字段：财务是否计算-是否不能为空",false);
      receptionServiceRes_7 = nbFinance.implementElevenReceivingField(receptionServiceReq_5);


      receptionServiceRes_3 = receptionServiceRes_7;
      }
AnalysisPreCurTargetContFinDataComRespDto retData = new AnalysisPreCurTargetContFinDataComRespDto();
  if(receptionServiceRes_3!=null){
      retData.setTureOrFalse(receptionServiceRes_3.getTureOrFalse());//SimpleFieldAssign//sourceId:1919862_1
    }
  if(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1!=null){
      retData.setBudgetAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetAccountId());//SimpleFieldAssign//sourceId:1916992_1
retData.setEntityAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getEntityAccountId());//SimpleFieldAssign//sourceId:1916993_1
retData.setRelSubBudgetAccountId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getRelSubBudgetAccountId());//SimpleFieldAssign//sourceId:1916994_1
retData.setRelSubBudgetAccountCode(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getRelSubBudgetAccountCode());//SimpleFieldAssign//sourceId:1917000_1
retData.setIsIncomingAccount(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1916995_1
retData.setBillAmount(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBillAmount());//SimpleFieldAssign//sourceId:1916996_1
retData.setFundUsageSubjectld(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getFundUsageSubjectld());//SimpleFieldAssign//sourceId:1916997_1
retData.setBudgetExpenditureAsld(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetExpenditureAsld());//SimpleFieldAssign//sourceId:1916998_1
retData.setBudgetExpensesReceivedAsId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getBudgetExpensesReceivedAsId());//SimpleFieldAssign//sourceId:1916999_1
retData.setStoryBillBusiness(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getStoryBillBusiness());//SimpleFieldAssign//sourceId:1917001_1
retData.setOperationInductionId(implementGenerateBillBusinessStoriesAndAccountInfoComRespDto_1.getOperationInductionId());//SimpleFieldAssign//sourceId:1917002_1
    }
if(implementIsOrgOfficialAccountNomAnalyzeComRespDto_1!=null){
      retData.setIsOrgOfficialAccountNom(implementIsOrgOfficialAccountNomAnalyzeComRespDto_1.getIsOrgOfficialAccountNom());//SimpleFieldAssign//sourceId:1916960_1
    }
if(querySpaceDetailComRespDto_1!=null){
      retData.setSpaceLogo(querySpaceDetailComRespDto_1.getSpaceLogo());//SimpleFieldAssign//sourceId:1917033_1
retData.setAbbreviation(querySpaceDetailComRespDto_1.getAbbreviation());//SimpleFieldAssign//sourceId:1917034_1
    }




return retData;
  }
  //
}
